block_size 83 arch/arm/mach-omap2/control.c u32 block_size; block_size 394 arch/arm/mach-omap2/control.c sdrc_block_contents.block_size = 0x0; block_size 951 arch/arm/mm/cache-l2x0.c u32 block_size = 0; block_size 956 arch/arm/mm/cache-l2x0.c of_property_read_u32(np, "cache-block-size", &block_size); block_size 964 arch/arm/mm/cache-l2x0.c if (block_size) { block_size 966 arch/arm/mm/cache-l2x0.c line_size = block_size; block_size 284 arch/mips/include/asm/octeon/cvmx-fpa.h uint64_t block_size, uint64_t num_blocks); block_size 42 arch/powerpc/include/asm/cache.h u32 block_size; /* L1 only */ block_size 65 arch/powerpc/include/asm/cache.h return ppc64_caches.l1d.block_size; block_size 75 arch/powerpc/include/asm/cache.h return ppc64_caches.l1i.block_size; block_size 55 arch/powerpc/include/asm/page_64.h onex = ppc64_caches.l1d.block_size; block_size 172 arch/powerpc/kernel/asm-offsets.c OFFSET(DCACHEL1BLOCKSIZE, ppc64_caches, l1d.block_size); block_size 175 arch/powerpc/kernel/asm-offsets.c OFFSET(ICACHEL1BLOCKSIZE, ppc64_caches, l1i.block_size); block_size 167 arch/powerpc/kernel/rtas_flash.c unsigned long block_size, image_size; block_size 176 arch/powerpc/kernel/rtas_flash.c block_size = f->blocks[i].length; block_size 177 arch/powerpc/kernel/rtas_flash.c if (block_size <= 0 || block_size > RTAS_BLK_SIZE) { block_size 180 arch/powerpc/kernel/rtas_flash.c image_size += block_size; block_size 82 arch/powerpc/kernel/setup_64.c .block_size = 0x40, block_size 86 arch/powerpc/kernel/setup_64.c .block_size = 0x40, block_size 497 arch/powerpc/kernel/setup_64.c info->block_size = bsize; block_size 622 arch/powerpc/kernel/setup_64.c dcache_bsize = ppc64_caches.l1d.block_size; block_size 623 arch/powerpc/kernel/setup_64.c icache_bsize = ppc64_caches.l1i.block_size; block_size 721 arch/powerpc/kernel/vdso.c vdso_data->dcache_block_size = ppc64_caches.l1d.block_size; block_size 722 arch/powerpc/kernel/vdso.c vdso_data->icache_block_size = ppc64_caches.l1i.block_size; block_size 887 arch/powerpc/lib/sstep.c size = ppc64_caches.l1d.block_size; block_size 153 arch/powerpc/mm/book3s32/mmu.c unsigned int size = block_size(base, top); block_size 196 arch/powerpc/mm/book3s32/mmu.c size = block_size(base, top); block_size 201 arch/powerpc/mm/book3s32/mmu.c size = block_size(base, top); block_size 501 arch/powerpc/mm/book3s64/hash_utils.c long unsigned int block_size; block_size 519 arch/powerpc/mm/book3s64/hash_utils.c block_size = be64_to_cpu(addr_prop[1]); block_size 520 arch/powerpc/mm/book3s64/hash_utils.c if (block_size != (16 * GB)) block_size 524 arch/powerpc/mm/book3s64/hash_utils.c phys_addr, block_size, expected_pages); block_size 525 arch/powerpc/mm/book3s64/hash_utils.c if (phys_addr + block_size * expected_pages <= memblock_end_of_DRAM()) { block_size 526 arch/powerpc/mm/book3s64/hash_utils.c memblock_reserve(phys_addr, block_size * expected_pages); block_size 527 arch/powerpc/mm/book3s64/hash_utils.c pseries_add_gpage(phys_addr, block_size, expected_pages); block_size 1367 arch/powerpc/platforms/pseries/lpar.c unsigned int block_size) block_size 1369 arch/powerpc/platforms/pseries/lpar.c if (block_size > hblkrm_size[bpsize][psize]) block_size 1370 arch/powerpc/platforms/pseries/lpar.c hblkrm_size[bpsize][psize] = block_size; block_size 1384 arch/powerpc/platforms/pseries/lpar.c unsigned int block_size) block_size 1390 arch/powerpc/platforms/pseries/lpar.c set_hblkrm_bloc_size(MMU_PAGE_4K, MMU_PAGE_4K, block_size); block_size 1400 arch/powerpc/platforms/pseries/lpar.c set_hblkrm_bloc_size(bpsize, psize, block_size); block_size 1455 arch/powerpc/platforms/pseries/lpar.c u32 block_size; block_size 1461 arch/powerpc/platforms/pseries/lpar.c block_size = 1 << block_shift; block_size 1466 arch/powerpc/platforms/pseries/lpar.c block_size); block_size 30 arch/powerpc/platforms/pseries/papr_scm.c uint64_t block_size; block_size 132 arch/powerpc/platforms/pseries/papr_scm.c if ((end_addr - start_addr) != ((p->blocks - 1) * p->block_size)) block_size 367 arch/powerpc/platforms/pseries/papr_scm.c mapping.size = p->blocks * p->block_size; // XXX: potential overflow? block_size 407 arch/powerpc/platforms/pseries/papr_scm.c u64 blocks, block_size; block_size 419 arch/powerpc/platforms/pseries/papr_scm.c if (of_property_read_u64(dn, "ibm,block-size", &block_size)) { block_size 444 arch/powerpc/platforms/pseries/papr_scm.c p->block_size = block_size; block_size 479 arch/powerpc/platforms/pseries/papr_scm.c p->res.end = p->bound_addr + p->blocks * p->block_size - 1; block_size 194 arch/s390/include/uapi/asm/vtoc.h __u32 block_size; /* Disk block size */ block_size 378 block/compat_ioctl.c return compat_put_int(arg, block_size(bdev)); block_size 550 block/ioctl.c return put_int(arg, block_size(bdev)); block_size 256 block/partitions/ibm.c blocksize = label->cms.block_size; block_size 52 block/partitions/mac.c secsize = be16_to_cpu(md->block_size); block_size 40 block/partitions/mac.h __be16 block_size; block_size 1046 drivers/block/loop.c block_size(inode->i_bdev) : PAGE_SIZE); block_size 22 drivers/block/rsxx/config.c cfg->data.block_size = RSXX_HW_BLK_SIZE; block_size 181 drivers/block/rsxx/config.c card->config.data.block_size); block_size 267 drivers/block/rsxx/dev.c blk_size = card->config.data.block_size; block_size 30 drivers/block/rsxx/rsxx_cfg.h __u32 block_size; block_size 505 drivers/block/zram/zram_drv.c old_block_size = block_size(bdev); block_size 108 drivers/crypto/atmel-aes.c u16 block_size; block_size 414 drivers/crypto/atmel-aes.c static inline size_t atmel_aes_padlen(size_t len, size_t block_size) block_size 416 drivers/crypto/atmel-aes.c len &= block_size - 1; block_size 417 drivers/crypto/atmel-aes.c return len ? block_size - len : 0; block_size 644 drivers/crypto/atmel-aes.c if (!IS_ALIGNED(len, dd->ctx->block_size)) block_size 652 drivers/crypto/atmel-aes.c if (!IS_ALIGNED(len, dd->ctx->block_size)) block_size 661 drivers/crypto/atmel-aes.c if (!IS_ALIGNED(sg->length, dd->ctx->block_size)) block_size 706 drivers/crypto/atmel-aes.c padlen = atmel_aes_padlen(len, dd->ctx->block_size); block_size 862 drivers/crypto/atmel-aes.c switch (dd->ctx->block_size) { block_size 986 drivers/crypto/atmel-aes.c dd->ctx->block_size != AES_BLOCK_SIZE); block_size 1094 drivers/crypto/atmel-aes.c ctx->block_size = CFB8_BLOCK_SIZE; block_size 1098 drivers/crypto/atmel-aes.c ctx->block_size = CFB16_BLOCK_SIZE; block_size 1102 drivers/crypto/atmel-aes.c ctx->block_size = CFB32_BLOCK_SIZE; block_size 1106 drivers/crypto/atmel-aes.c ctx->block_size = CFB64_BLOCK_SIZE; block_size 1110 drivers/crypto/atmel-aes.c ctx->block_size = AES_BLOCK_SIZE; block_size 1751 drivers/crypto/atmel-aes.c ctx->block_size = AES_BLOCK_SIZE; block_size 2229 drivers/crypto/atmel-aes.c ctx->block_size = AES_BLOCK_SIZE; block_size 103 drivers/crypto/atmel-sha.c size_t block_size; block_size 442 drivers/crypto/atmel-sha.c ctx->block_size = SHA1_BLOCK_SIZE; block_size 446 drivers/crypto/atmel-sha.c ctx->block_size = SHA224_BLOCK_SIZE; block_size 450 drivers/crypto/atmel-sha.c ctx->block_size = SHA256_BLOCK_SIZE; block_size 454 drivers/crypto/atmel-sha.c ctx->block_size = SHA384_BLOCK_SIZE; block_size 458 drivers/crypto/atmel-sha.c ctx->block_size = SHA512_BLOCK_SIZE; block_size 721 drivers/crypto/atmel-sha.c ctx->buflen + ctx->block_size, DMA_TO_DEVICE); block_size 724 drivers/crypto/atmel-sha.c ctx->block_size); block_size 780 drivers/crypto/atmel-sha.c if (!sg_is_last(sg) && !IS_ALIGNED(sg->length, ctx->block_size)) block_size 789 drivers/crypto/atmel-sha.c tail = length & (ctx->block_size - 1); block_size 801 drivers/crypto/atmel-sha.c tail = length & (ctx->block_size - 1); block_size 812 drivers/crypto/atmel-sha.c ctx->buflen + ctx->block_size, DMA_TO_DEVICE); block_size 815 drivers/crypto/atmel-sha.c ctx->buflen + ctx->block_size); block_size 867 drivers/crypto/atmel-sha.c ctx->buflen + ctx->block_size, DMA_TO_DEVICE); block_size 871 drivers/crypto/atmel-sha.c ctx->block_size, DMA_TO_DEVICE); block_size 1461 drivers/crypto/atmel-sha.c size_t bs = ctx->block_size; block_size 1596 drivers/crypto/atmel-sha.c ctx->bufcnt = min_t(size_t, ctx->block_size, ctx->total); block_size 1642 drivers/crypto/atmel-sha.c ctx->bufcnt = min_t(size_t, ctx->block_size, ctx->total); block_size 1660 drivers/crypto/atmel-sha.c if (!(IS_ALIGNED(datalen, ctx->block_size) || auto_padding)) block_size 1764 drivers/crypto/atmel-sha.c ctx->block_size = SHA1_BLOCK_SIZE; block_size 1769 drivers/crypto/atmel-sha.c ctx->block_size = SHA224_BLOCK_SIZE; block_size 1774 drivers/crypto/atmel-sha.c ctx->block_size = SHA256_BLOCK_SIZE; block_size 1779 drivers/crypto/atmel-sha.c ctx->block_size = SHA384_BLOCK_SIZE; block_size 1784 drivers/crypto/atmel-sha.c ctx->block_size = SHA512_BLOCK_SIZE; block_size 1791 drivers/crypto/atmel-sha.c bs = ctx->block_size; block_size 1820 drivers/crypto/atmel-sha.c size_t bs = ctx->block_size; block_size 1836 drivers/crypto/atmel-sha.c size_t bs = ctx->block_size; block_size 1855 drivers/crypto/atmel-sha.c size_t bs = ctx->block_size; block_size 1941 drivers/crypto/atmel-sha.c size_t bs = ctx->block_size; block_size 1960 drivers/crypto/atmel-sha.c size_t bs = ctx->block_size; block_size 78 drivers/crypto/atmel-tdes.c u16 block_size; block_size 514 drivers/crypto/atmel-tdes.c IS_ALIGNED(dd->in_sg->length, dd->ctx->block_size); block_size 516 drivers/crypto/atmel-tdes.c IS_ALIGNED(dd->out_sg->length, dd->ctx->block_size); block_size 679 drivers/crypto/atmel-tdes.c ctx->block_size = CFB8_BLOCK_SIZE; block_size 685 drivers/crypto/atmel-tdes.c ctx->block_size = CFB16_BLOCK_SIZE; block_size 691 drivers/crypto/atmel-tdes.c ctx->block_size = CFB32_BLOCK_SIZE; block_size 697 drivers/crypto/atmel-tdes.c ctx->block_size = DES_BLOCK_SIZE; block_size 62 drivers/crypto/ccp/ccp-crypto-aes-cmac.c unsigned int block_size = block_size 77 drivers/crypto/ccp/ccp-crypto-aes-cmac.c if (!final && (len <= block_size)) { block_size 89 drivers/crypto/ccp/ccp-crypto-aes-cmac.c rctx->hash_rem = final ? 0 : len & (block_size - 1); block_size 93 drivers/crypto/ccp/ccp-crypto-aes-cmac.c rctx->hash_cnt -= block_size; block_size 94 drivers/crypto/ccp/ccp-crypto-aes-cmac.c rctx->hash_rem = block_size; block_size 97 drivers/crypto/ccp/ccp-crypto-aes-cmac.c if (final && (rctx->null_msg || (len & (block_size - 1)))) block_size 133 drivers/crypto/ccp/ccp-crypto-aes-cmac.c int pad_length = block_size - (len & (block_size - 1)); block_size 63 drivers/crypto/ccp/ccp-crypto-sha.c unsigned int block_size = block_size 72 drivers/crypto/ccp/ccp-crypto-sha.c if (!final && (len <= block_size)) { block_size 84 drivers/crypto/ccp/ccp-crypto-sha.c rctx->hash_rem = final ? 0 : len & (block_size - 1); block_size 88 drivers/crypto/ccp/ccp-crypto-sha.c rctx->hash_cnt -= block_size; block_size 89 drivers/crypto/ccp/ccp-crypto-sha.c rctx->hash_rem = block_size; block_size 187 drivers/crypto/ccp/ccp-crypto-sha.c unsigned int block_size = block_size 197 drivers/crypto/ccp/ccp-crypto-sha.c memcpy(rctx->buf, ctx->u.sha.ipad, block_size); block_size 198 drivers/crypto/ccp/ccp-crypto-sha.c rctx->buf_count = block_size; block_size 278 drivers/crypto/ccp/ccp-crypto-sha.c unsigned int block_size = crypto_shash_blocksize(shash); block_size 290 drivers/crypto/ccp/ccp-crypto-sha.c if (key_len > block_size) { block_size 306 drivers/crypto/ccp/ccp-crypto-sha.c for (i = 0; i < block_size; i++) { block_size 311 drivers/crypto/ccp/ccp-crypto-sha.c sg_init_one(&ctx->u.sha.opad_sg, ctx->u.sha.opad, block_size); block_size 312 drivers/crypto/ccp/ccp-crypto-sha.c ctx->u.sha.opad_count = block_size; block_size 370 drivers/crypto/ccp/ccp-crypto-sha.c u32 block_size; block_size 380 drivers/crypto/ccp/ccp-crypto-sha.c .block_size = SHA1_BLOCK_SIZE, block_size 388 drivers/crypto/ccp/ccp-crypto-sha.c .block_size = SHA224_BLOCK_SIZE, block_size 396 drivers/crypto/ccp/ccp-crypto-sha.c .block_size = SHA256_BLOCK_SIZE, block_size 404 drivers/crypto/ccp/ccp-crypto-sha.c .block_size = SHA384_BLOCK_SIZE, block_size 412 drivers/crypto/ccp/ccp-crypto-sha.c .block_size = SHA512_BLOCK_SIZE, block_size 498 drivers/crypto/ccp/ccp-crypto-sha.c base->cra_blocksize = def->block_size; block_size 324 drivers/crypto/ccp/ccp-ops.c struct ccp_op *op, unsigned int block_size, block_size 349 drivers/crypto/ccp/ccp-ops.c op_len = max(op_len, block_size); block_size 354 drivers/crypto/ccp/ccp-ops.c if (sg_src_len < block_size) { block_size 363 drivers/crypto/ccp/ccp-ops.c op->src.u.dma.length = (blocksize_op) ? block_size : cp_len; block_size 370 drivers/crypto/ccp/ccp-ops.c op->src.u.dma.length = op_len & ~(block_size - 1); block_size 376 drivers/crypto/ccp/ccp-ops.c if (sg_dst_len < block_size) { block_size 1480 drivers/crypto/ccp/ccp-ops.c u64 block_size; block_size 1488 drivers/crypto/ccp/ccp-ops.c block_size = SHA1_BLOCK_SIZE; block_size 1493 drivers/crypto/ccp/ccp-ops.c block_size = SHA224_BLOCK_SIZE; block_size 1498 drivers/crypto/ccp/ccp-ops.c block_size = SHA256_BLOCK_SIZE; block_size 1504 drivers/crypto/ccp/ccp-ops.c block_size = SHA384_BLOCK_SIZE; block_size 1510 drivers/crypto/ccp/ccp-ops.c block_size = SHA512_BLOCK_SIZE; block_size 1519 drivers/crypto/ccp/ccp-ops.c if (!sha->final && (sha->src_len & (block_size - 1))) block_size 1677 drivers/crypto/ccp/ccp-ops.c block_size, DMA_TO_DEVICE); block_size 1682 drivers/crypto/ccp/ccp-ops.c ccp_prepare_data(&src, NULL, &op, block_size, false); block_size 1748 drivers/crypto/ccp/ccp-ops.c if (sha->opad_len != block_size) { block_size 1753 drivers/crypto/ccp/ccp-ops.c hmac_buf = kmalloc(block_size + digest_size, GFP_KERNEL); block_size 1758 drivers/crypto/ccp/ccp-ops.c sg_init_one(&sg, hmac_buf, block_size + digest_size); block_size 1760 drivers/crypto/ccp/ccp-ops.c scatterwalk_map_and_copy(hmac_buf, sha->opad, 0, block_size, 0); block_size 1765 drivers/crypto/ccp/ccp-ops.c memcpy(hmac_buf + block_size, block_size 1771 drivers/crypto/ccp/ccp-ops.c memcpy(hmac_buf + block_size, block_size 1774 drivers/crypto/ccp/ccp-ops.c memcpy(hmac_buf + block_size + block_size 1790 drivers/crypto/ccp/ccp-ops.c hmac_cmd.u.sha.src_len = block_size + digest_size; block_size 1795 drivers/crypto/ccp/ccp-ops.c hmac_cmd.u.sha.msg_bits = (block_size + digest_size) << 3; block_size 1285 drivers/crypto/ccree/cc_buffer_mgr.c unsigned int block_size, gfp_t flags) block_size 1312 drivers/crypto/ccree/cc_buffer_mgr.c if (total_in_len < block_size) { block_size 1323 drivers/crypto/ccree/cc_buffer_mgr.c *next_buff_cnt = total_in_len & (block_size - 1); block_size 62 drivers/crypto/ccree/cc_buffer_mgr.h unsigned int block_size, gfp_t flags); block_size 554 drivers/crypto/ccree/cc_hash.c unsigned int block_size = crypto_tfm_alg_blocksize(&tfm->base); block_size 573 drivers/crypto/ccree/cc_hash.c block_size, flags); block_size 1155 drivers/crypto/ccree/cc_hash.c unsigned int block_size = crypto_tfm_alg_blocksize(&tfm->base); block_size 1170 drivers/crypto/ccree/cc_hash.c req->nbytes, block_size, flags); block_size 825 drivers/crypto/n2_core.c static inline int cipher_descriptor_len(int nbytes, unsigned int block_size) block_size 829 drivers/crypto/n2_core.c this_len -= (nbytes & (block_size - 1)); block_size 1123 drivers/crypto/n2_core.c u8 block_size; block_size 1132 drivers/crypto/n2_core.c .block_size = 1, block_size 1147 drivers/crypto/n2_core.c .block_size = DES_BLOCK_SIZE, block_size 1160 drivers/crypto/n2_core.c .block_size = DES_BLOCK_SIZE, block_size 1174 drivers/crypto/n2_core.c .block_size = DES_BLOCK_SIZE, block_size 1189 drivers/crypto/n2_core.c .block_size = DES_BLOCK_SIZE, block_size 1202 drivers/crypto/n2_core.c .block_size = DES_BLOCK_SIZE, block_size 1216 drivers/crypto/n2_core.c .block_size = DES_BLOCK_SIZE, block_size 1230 drivers/crypto/n2_core.c .block_size = AES_BLOCK_SIZE, block_size 1243 drivers/crypto/n2_core.c .block_size = AES_BLOCK_SIZE, block_size 1257 drivers/crypto/n2_core.c .block_size = AES_BLOCK_SIZE, block_size 1281 drivers/crypto/n2_core.c u8 block_size; block_size 1312 drivers/crypto/n2_core.c .block_size = MD5_HMAC_BLOCK_SIZE }, block_size 1320 drivers/crypto/n2_core.c .block_size = SHA1_BLOCK_SIZE }, block_size 1328 drivers/crypto/n2_core.c .block_size = SHA256_BLOCK_SIZE }, block_size 1336 drivers/crypto/n2_core.c .block_size = SHA224_BLOCK_SIZE }, block_size 1390 drivers/crypto/n2_core.c alg->cra_blocksize = tmpl->block_size; block_size 1484 drivers/crypto/n2_core.c base->cra_blocksize = tmpl->block_size; block_size 157 drivers/crypto/qat/qat_common/qat_algs.c int block_size = crypto_shash_blocksize(ctx->hash_tfm); block_size 163 drivers/crypto/qat/qat_common/qat_algs.c memset(ctx->ipad, 0, block_size); block_size 164 drivers/crypto/qat/qat_common/qat_algs.c memset(ctx->opad, 0, block_size); block_size 167 drivers/crypto/qat/qat_common/qat_algs.c if (auth_keylen > block_size) { block_size 179 drivers/crypto/qat/qat_common/qat_algs.c for (i = 0; i < block_size; i++) { block_size 189 drivers/crypto/qat/qat_common/qat_algs.c if (crypto_shash_update(shash, ctx->ipad, block_size)) block_size 221 drivers/crypto/qat/qat_common/qat_algs.c if (crypto_shash_update(shash, ctx->opad, block_size)) block_size 253 drivers/crypto/qat/qat_common/qat_algs.c memzero_explicit(ctx->ipad, block_size); block_size 254 drivers/crypto/qat/qat_common/qat_algs.c memzero_explicit(ctx->opad, block_size); block_size 929 drivers/crypto/sahara.c unsigned int block_size; block_size 932 drivers/crypto/sahara.c block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); block_size 938 drivers/crypto/sahara.c if (!rctx->last && (len < block_size)) { block_size 952 drivers/crypto/sahara.c hash_later = rctx->last ? 0 : len & (block_size - 1); block_size 199 drivers/dma/coh901318_lli.c size_t block_size = MAX_DMA_PACKET_SIZE; block_size 209 drivers/dma/coh901318_lli.c block_size = MAX_DMA_PACKET_SIZE/2; block_size 211 drivers/dma/coh901318_lli.c s -= block_size; block_size 218 drivers/dma/coh901318_lli.c src += block_size; block_size 220 drivers/dma/coh901318_lli.c dst += block_size; block_size 437 drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c max_block_ts = chan->chip->dw->hdata->block_size[chan->id]; block_size 791 drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c chip->dw->hdata->block_size[tmp] = carr[tmp]; block_size 29 drivers/dma/dw-axi-dmac/dw-axi-dmac.h u32 block_size[DMAC_MAX_CHANNELS]; block_size 1089 drivers/dma/dw/core.c pdata->block_size = dma_readl(dw, MAX_BLK_SIZE); block_size 1179 drivers/dma/dw/core.c dwc->block_size = block_size 1180 drivers/dma/dw/core.c (4 << ((pdata->block_size >> 4 * i) & 0xf)) - 1; block_size 1184 drivers/dma/dw/core.c dwc->block_size = pdata->block_size; block_size 51 drivers/dma/dw/dw.c if ((bytes >> width) > dwc->block_size) { block_size 52 drivers/dma/dw/dw.c block = dwc->block_size; block_size 53 drivers/dma/dw/dw.c *len = dwc->block_size << width; block_size 57 drivers/dma/dw/idma32.c if (bytes > dwc->block_size) { block_size 58 drivers/dma/dw/idma32.c block = dwc->block_size; block_size 59 drivers/dma/dw/idma32.c *len = dwc->block_size; block_size 65 drivers/dma/dw/internal.h .block_size = 131071, block_size 83 drivers/dma/dw/of.c pdata->block_size = tmp; block_size 284 drivers/dma/dw/regs.h unsigned int block_size; block_size 91 drivers/fpga/altera-cvp.c size_t block_size; block_size 455 drivers/fpga/altera-cvp.c len = min(conf->priv->block_size, remaining); block_size 527 drivers/fpga/altera-cvp.c .block_size = ALTERA_CVP_V1_SIZE, block_size 535 drivers/fpga/altera-cvp.c .block_size = ALTERA_CVP_V2_SIZE, block_size 104 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c adev->vm_manager.block_size; block_size 2628 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c adev->vm_manager.block_size = block_size 2633 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c adev->vm_manager.block_size = 9; block_size 2635 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c adev->vm_manager.block_size = amdgpu_vm_get_block_size(tmp); block_size 2644 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c adev->vm_manager.block_size, block_size 50 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h #define AMDGPU_VM_PTE_COUNT(adev) (1 << (adev)->vm_manager.block_size) block_size 304 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h uint32_t block_size; block_size 203 drivers/gpu/drm/amd/amdgpu/gfxhub_v1_0.c unsigned num_level, block_size; block_size 208 drivers/gpu/drm/amd/amdgpu/gfxhub_v1_0.c block_size = adev->vm_manager.block_size; block_size 212 drivers/gpu/drm/amd/amdgpu/gfxhub_v1_0.c block_size -= 9; block_size 236 drivers/gpu/drm/amd/amdgpu/gfxhub_v1_0.c block_size); block_size 224 drivers/gpu/drm/amd/amdgpu/gfxhub_v2_0.c adev->vm_manager.block_size - 9); block_size 567 drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c ((adev->vm_manager.block_size - 9) block_size 667 drivers/gpu/drm/amd/amdgpu/gmc_v7_0.c adev->vm_manager.block_size - 9); block_size 917 drivers/gpu/drm/amd/amdgpu/gmc_v8_0.c adev->vm_manager.block_size - 9); block_size 235 drivers/gpu/drm/amd/amdgpu/mmhub_v1_0.c unsigned num_level, block_size; block_size 240 drivers/gpu/drm/amd/amdgpu/mmhub_v1_0.c block_size = adev->vm_manager.block_size; block_size 244 drivers/gpu/drm/amd/amdgpu/mmhub_v1_0.c block_size -= 9; block_size 268 drivers/gpu/drm/amd/amdgpu/mmhub_v1_0.c block_size); block_size 214 drivers/gpu/drm/amd/amdgpu/mmhub_v2_0.c adev->vm_manager.block_size - 9); block_size 311 drivers/gpu/drm/amd/amdgpu/mmhub_v9_4.c adev->vm_manager.block_size - 9); block_size 330 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hubbub.c enum dcn_hubbub_page_table_block_size block_size = 0; block_size 334 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hubbub.c block_size = DCN_PAGE_TABLE_BLOCK_SIZE_4KB; block_size 337 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hubbub.c block_size = DCN_PAGE_TABLE_BLOCK_SIZE_64KB; block_size 341 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hubbub.c block_size = page_table_block_size; block_size 345 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hubbub.c return block_size; block_size 358 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hubbub.c virt_config.block_size = page_table_block_size_to_hw(va_config->page_table_block_size); block_size 393 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hubbub.c phys_config.block_size = 0; block_size 87 drivers/gpu/drm/amd/display/dc/dcn20/dcn20_vmid.c VM_CONTEXT0_PAGE_TABLE_BLOCK_SIZE, config->block_size); block_size 46 drivers/gpu/drm/amd/display/dc/inc/hw/vmid.h enum dcn_hubbub_page_table_block_size block_size; block_size 71 drivers/gpu/drm/drm_fb_cma_helper.c u32 block_size = fb->format->char_per_block[plane]; block_size 94 drivers/gpu/drm/drm_fb_cma_helper.c paddr += block_size * num_hblocks; block_size 204 drivers/gpu/drm/drm_framebuffer.c unsigned int block_size = info->char_per_block[i]; block_size 207 drivers/gpu/drm/drm_framebuffer.c if (!block_size && (r->modifier[i] == DRM_FORMAT_MOD_LINEAR)) { block_size 223 drivers/gpu/drm/drm_framebuffer.c if (block_size && r->pitches[i] < min_pitch) { block_size 139 drivers/gpu/drm/gma500/intel_bios.c u16 *block_ptr, block_size; block_size 142 drivers/gpu/drm/gma500/intel_bios.c block_size = *block_ptr; block_size 143 drivers/gpu/drm/gma500/intel_bios.c return block_size; block_size 330 drivers/gpu/drm/gma500/intel_bios.c u16 block_size; block_size 348 drivers/gpu/drm/gma500/intel_bios.c block_size = get_blocksize(p_defs); block_size 350 drivers/gpu/drm/gma500/intel_bios.c child_device_num = (block_size - sizeof(*p_defs)) / block_size 443 drivers/gpu/drm/gma500/intel_bios.c u16 block_size; block_size 461 drivers/gpu/drm/gma500/intel_bios.c block_size = get_blocksize(p_defs); block_size 463 drivers/gpu/drm/gma500/intel_bios.c child_device_num = (block_size - sizeof(*p_defs)) / block_size 1597 drivers/gpu/drm/i915/display/intel_bios.c u16 block_size; block_size 1606 drivers/gpu/drm/i915/display/intel_bios.c block_size = get_blocksize(defs); block_size 1607 drivers/gpu/drm/i915/display/intel_bios.c if (block_size < sizeof(*defs)) { block_size 1609 drivers/gpu/drm/i915/display/intel_bios.c block_size); block_size 1650 drivers/gpu/drm/i915/display/intel_bios.c child_device_num = (block_size - sizeof(*defs)) / defs->child_dev_size; block_size 19 drivers/gpu/drm/i915/gem/i915_gem_object_blt.c const u32 block_size = S16_MAX * PAGE_SIZE; block_size 32 drivers/gpu/drm/i915/gem/i915_gem_object_blt.c count = div_u64(vma->size, block_size); block_size 51 drivers/gpu/drm/i915/gem/i915_gem_object_blt.c u32 size = min_t(u64, rem, block_size); block_size 203 drivers/gpu/drm/i915/gem/i915_gem_object_blt.c const u32 block_size = S16_MAX * PAGE_SIZE; block_size 216 drivers/gpu/drm/i915/gem/i915_gem_object_blt.c count = div_u64(dst->size, block_size); block_size 236 drivers/gpu/drm/i915/gem/i915_gem_object_blt.c size = min_t(u64, rem, block_size); block_size 44 drivers/gpu/drm/i915/selftests/i915_buddy.c u64 block_size; block_size 57 drivers/gpu/drm/i915/selftests/i915_buddy.c block_size = i915_buddy_block_size(mm, block); block_size 60 drivers/gpu/drm/i915/selftests/i915_buddy.c if (block_size < mm->chunk_size) { block_size 65 drivers/gpu/drm/i915/selftests/i915_buddy.c if (!is_power_of_2(block_size)) { block_size 70 drivers/gpu/drm/i915/selftests/i915_buddy.c if (!IS_ALIGNED(block_size, mm->chunk_size)) { block_size 80 drivers/gpu/drm/i915/selftests/i915_buddy.c if (!IS_ALIGNED(offset, block_size)) { block_size 93 drivers/gpu/drm/i915/selftests/i915_buddy.c if (i915_buddy_block_offset(buddy) != (offset ^ block_size)) { block_size 98 drivers/gpu/drm/i915/selftests/i915_buddy.c if (i915_buddy_block_size(mm, buddy) != block_size) { block_size 24 drivers/gpu/drm/nouveau/include/nvkm/core/mm.h u32 block_size; block_size 145 drivers/gpu/drm/nouveau/nouveau_abi16.c if (chan->heap.block_size) block_size 131 drivers/gpu/drm/nouveau/nvkm/core/mm.c s = roundup(s, mm->block_size); block_size 135 drivers/gpu/drm/nouveau/nvkm/core/mm.c e = rounddown(e, mm->block_size); block_size 205 drivers/gpu/drm/nouveau/nvkm/core/mm.c s = roundup(s, mm->block_size); block_size 209 drivers/gpu/drm/nouveau/nvkm/core/mm.c e = rounddown(e, mm->block_size); block_size 257 drivers/gpu/drm/nouveau/nvkm/core/mm.c BUG_ON(block != mm->block_size); block_size 261 drivers/gpu/drm/nouveau/nvkm/core/mm.c mm->block_size = block; block_size 270 drivers/gpu/drm/nouveau/nvkm/core/mm.c node->offset = roundup(offset, mm->block_size); block_size 271 drivers/gpu/drm/nouveau/nvkm/core/mm.c node->length = rounddown(offset + length, mm->block_size); block_size 194 drivers/gpu/drm/omapdrm/dss/hdmi.h u8 block_size; block_size 822 drivers/gpu/drm/omapdrm/dss/hdmi4_core.c audio_dma.block_size = 0xC0; block_size 864 drivers/gpu/drm/omapdrm/dss/hdmi5_core.c audio_dma.block_size = 0xC0; block_size 255 drivers/gpu/drm/omapdrm/dss/hdmi_wp.c r = FLD_MOD(r, aud_dma->block_size, 7, 0); block_size 160 drivers/gpu/drm/tiny/gm12u320.c int i, block_size; block_size 169 drivers/gpu/drm/tiny/gm12u320.c block_size = DATA_LAST_BLOCK_SIZE; block_size 172 drivers/gpu/drm/tiny/gm12u320.c block_size = DATA_BLOCK_SIZE; block_size 176 drivers/gpu/drm/tiny/gm12u320.c gm12u320->data_buf[i] = kzalloc(block_size, GFP_KERNEL); block_size 182 drivers/gpu/drm/tiny/gm12u320.c (block_size - DATA_BLOCK_FOOTER_SIZE), block_size 350 drivers/gpu/drm/tiny/gm12u320.c int block, block_size, len; block_size 359 drivers/gpu/drm/tiny/gm12u320.c block_size = DATA_LAST_BLOCK_SIZE; block_size 361 drivers/gpu/drm/tiny/gm12u320.c block_size = DATA_BLOCK_SIZE; block_size 365 drivers/gpu/drm/tiny/gm12u320.c gm12u320->cmd_buf[8] = block_size & 0xff; block_size 366 drivers/gpu/drm/tiny/gm12u320.c gm12u320->cmd_buf[9] = block_size >> 8; block_size 380 drivers/gpu/drm/tiny/gm12u320.c gm12u320->data_buf[block], block_size, block_size 382 drivers/gpu/drm/tiny/gm12u320.c if (ret || len != block_size) block_size 373 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h surf_size_struct block_size; block_size 1147 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h surf_size_struct *block_size) block_size 1149 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h block_size->width = __KERNEL_DIV_ROUND_UP(pixel_size->width, block_size 1150 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h desc->block_size.width); block_size 1151 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h block_size->height = __KERNEL_DIV_ROUND_UP(pixel_size->height, block_size 1152 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h desc->block_size.height); block_size 1153 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h block_size->depth = __KERNEL_DIV_ROUND_UP(pixel_size->depth, block_size 1154 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h desc->block_size.depth); block_size 1272 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h const u32 bw = desc->block_size.width, bh = desc->block_size.height; block_size 1273 drivers/gpu/drm/vmwgfx/device_include/svga3d_surfacedefs.h const u32 bd = desc->block_size.depth; block_size 360 drivers/ide/ide-floppy.c lba_capacity = floppy->blocks * floppy->block_size; block_size 366 drivers/ide/ide-floppy.c floppy->blocks = floppy->block_size ? block_size 367 drivers/ide/ide-floppy.c capacity / floppy->block_size : 0; block_size 445 drivers/ide/ide-floppy.c floppy->block_size = length; block_size 34 drivers/ide/ide-gd.h int blocks, block_size, bs_factor; block_size 301 drivers/iio/buffer/industrialio-buffer-dma.c if (PAGE_ALIGN(queue->fileio.block_size) == PAGE_ALIGN(size)) block_size 304 drivers/iio/buffer/industrialio-buffer-dma.c queue->fileio.block_size = size; block_size 4492 drivers/infiniband/hw/mlx5/qp.c static u8 bs_selector(int block_size) block_size 4494 drivers/infiniband/hw/mlx5/qp.c switch (block_size) { block_size 4653 drivers/infiniband/hw/mlx5/qp.c u16 block_size = sig_attrs->mem.sig.dif.pi_interval; block_size 4662 drivers/infiniband/hw/mlx5/qp.c pr_err("Bad block size given: %u\n", block_size); block_size 4665 drivers/infiniband/hw/mlx5/qp.c sblock_ctrl->bcount_per_cycle = cpu_to_be32(block_size + block_size 4668 drivers/infiniband/hw/mlx5/qp.c sblock_ctrl->repeat_count = cpu_to_be32(data_len / block_size); block_size 4671 drivers/infiniband/hw/mlx5/qp.c data_sentry->bcount = cpu_to_be16(block_size); block_size 4674 drivers/infiniband/hw/mlx5/qp.c data_sentry->stride = cpu_to_be16(block_size); block_size 1622 drivers/infiniband/ulp/isert/ib_isert.c u32 block_size = se_cmd->se_dev->dev_attrib.block_size + 8; block_size 1636 drivers/infiniband/ulp/isert/ib_isert.c do_div(sec_offset_err, block_size); block_size 2066 drivers/infiniband/ulp/isert/ib_isert.c domain->sig.dif.pi_interval = se_cmd->se_dev->dev_attrib.block_size; block_size 149 drivers/input/rmi4/rmi_f34.c data, f34->v5.block_size); block_size 167 drivers/input/rmi4/rmi_f34.c data += f34->v5.block_size; block_size 168 drivers/input/rmi4/rmi_f34.c f34->update_progress += f34->v5.block_size; block_size 266 drivers/input/rmi4/rmi_f34.c if (image_size && image_size != f34->v5.fw_blocks * f34->v5.block_size) { block_size 269 drivers/input/rmi4/rmi_f34.c image_size, f34->v5.fw_blocks * f34->v5.block_size); block_size 275 drivers/input/rmi4/rmi_f34.c config_size != f34->v5.config_blocks * f34->v5.block_size) { block_size 279 drivers/input/rmi4/rmi_f34.c f34->v5.config_blocks * f34->v5.block_size); block_size 555 drivers/input/rmi4/rmi_f34.c f34->v5.block_size = get_unaligned_le16(&f34_queries[3]); block_size 559 drivers/input/rmi4/rmi_f34.c f34->v5.block_size; block_size 565 drivers/input/rmi4/rmi_f34.c f34->v5.block_size); block_size 124 drivers/input/rmi4/rmi_f34.h __le16 block_size; block_size 228 drivers/input/rmi4/rmi_f34.h u8 block_size; block_size 252 drivers/input/rmi4/rmi_f34.h u16 block_size; block_size 271 drivers/input/rmi4/rmi_f34.h u16 block_size; block_size 499 drivers/input/rmi4/rmi_f34v7.c f34->v7.block_size = le16_to_cpu(query_1_7.block_size); block_size 505 drivers/input/rmi4/rmi_f34v7.c __func__, f34->v7.block_size); block_size 578 drivers/input/rmi4/rmi_f34v7.c block_count = f34->v7.img.ui_firmware.size / f34->v7.block_size; block_size 595 drivers/input/rmi4/rmi_f34v7.c block_count = f34->v7.img.ui_config.size / f34->v7.block_size; block_size 610 drivers/input/rmi4/rmi_f34v7.c block_count = f34->v7.img.dp_config.size / f34->v7.block_size; block_size 625 drivers/input/rmi4/rmi_f34v7.c block_count = f34->v7.img.guest_code.size / f34->v7.block_size; block_size 640 drivers/input/rmi4/rmi_f34v7.c block_count = f34->v7.img.bl_config.size / f34->v7.block_size; block_size 768 drivers/input/rmi4/rmi_f34v7.c (u16)(PAGE_SIZE / f34->v7.block_size)); block_size 797 drivers/input/rmi4/rmi_f34v7.c transfer * f34->v7.block_size); block_size 805 drivers/input/rmi4/rmi_f34v7.c index += (transfer * f34->v7.block_size); block_size 839 drivers/input/rmi4/rmi_f34v7.c if (f34->v7.payload_length > (PAGE_SIZE / f34->v7.block_size)) block_size 840 drivers/input/rmi4/rmi_f34v7.c max_transfer = PAGE_SIZE / f34->v7.block_size; block_size 866 drivers/input/rmi4/rmi_f34v7.c block_ptr, transfer * f34->v7.block_size); block_size 878 drivers/input/rmi4/rmi_f34v7.c block_ptr += (transfer * f34->v7.block_size); block_size 900 drivers/input/rmi4/rmi_f34v7.c f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size; block_size 910 drivers/input/rmi4/rmi_f34v7.c f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size; block_size 919 drivers/input/rmi4/rmi_f34v7.c f34->v7.block_size, block_size 930 drivers/input/rmi4/rmi_f34v7.c f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size; block_size 965 drivers/input/rmi4/rmi_f34v7.c f34->v7.config_size = f34->v7.block_size * block_count; block_size 991 drivers/input/rmi4/rmi_f34v7.c f34->v7.config_block_count = f34->v7.config_size / f34->v7.block_size; block_size 1004 drivers/input/rmi4/rmi_f34v7.c blk_count = f34->v7.img.ui_firmware.size / f34->v7.block_size; block_size 387 drivers/iommu/io-pgtable-arm.c size_t block_size = ARM_LPAE_BLOCK_SIZE(lvl, data); block_size 395 drivers/iommu/io-pgtable-arm.c if (size == block_size && (size & cfg->pgsize_bitmap)) block_size 686 drivers/md/bcache/alloc.c if (b->sectors_free < c->sb.block_size) block_size 759 drivers/md/bcache/bcache.h #define block_bytes(c) ((c)->sb.block_size << 9) block_size 216 drivers/md/bcache/btree.c iter->size = b->c->sb.bucket_size / b->c->sb.block_size; block_size 484 drivers/md/bcache/btree.c atomic_long_add(set_blocks(i, block_bytes(b->c)) * b->c->sb.block_size, block_size 162 drivers/md/bcache/journal.c offset += blocks * ca->sb.block_size; block_size 163 drivers/md/bcache/journal.c len -= blocks * ca->sb.block_size; block_size 763 drivers/md/bcache/journal.c c->sb.block_size; block_size 877 drivers/md/bcache/journal.c block_bytes(c)) * c->sb.block_size; block_size 880 drivers/md/bcache/journal.c c->journal.blocks_free * c->sb.block_size, block_size 409 drivers/md/bcache/request.c if (bio->bi_iter.bi_sector & (c->sb.block_size - 1) || block_size 410 drivers/md/bcache/request.c bio_sectors(bio) & (c->sb.block_size - 1)) { block_size 114 drivers/md/bcache/super.c sb->block_size = le16_to_cpu(s->block_size); block_size 117 drivers/md/bcache/super.c if (sb->block_size << 9 < bdev_logical_block_size(bdev)) block_size 149 drivers/md/bcache/super.c if (!is_power_of_2(sb->block_size) || block_size 150 drivers/md/bcache/super.c sb->block_size > PAGE_SECTORS || block_size 810 drivers/md/bcache/super.c static int bcache_device_init(struct bcache_device *d, unsigned int block_size, block_size 875 drivers/md/bcache/super.c q->limits.io_min = block_size; block_size 876 drivers/md/bcache/super.c q->limits.logical_block_size = block_size; block_size 877 drivers/md/bcache/super.c q->limits.physical_block_size = block_size; block_size 1124 drivers/md/bcache/super.c if (dc->sb.block_size < c->sb.block_size) { block_size 1303 drivers/md/bcache/super.c static int cached_dev_init(struct cached_dev *dc, unsigned int block_size) block_size 1333 drivers/md/bcache/super.c ret = bcache_device_init(&dc->disk, block_size, block_size 1373 drivers/md/bcache/super.c if (cached_dev_init(dc, sb->block_size << 9)) block_size 1781 drivers/md/bcache/super.c c->sb.block_size = sb->block_size; block_size 1786 drivers/md/bcache/super.c c->block_bits = ilog2(sb->block_size); block_size 1815 drivers/md/bcache/super.c iter_size = (sb->bucket_size / sb->block_size + 1) * block_size 2045 drivers/md/bcache/super.c return ca->sb.block_size == c->sb.block_size && block_size 66 drivers/md/bcache/sysfs.c read_attribute(block_size); block_size 712 drivers/md/bcache/sysfs.c sysfs_hprint(block_size, block_bytes(c)); block_size 998 drivers/md/bcache/sysfs.c sysfs_hprint(block_size, block_bytes(ca)); block_size 89 drivers/md/dm-bufio.c unsigned block_size; block_size 306 drivers/md/dm-bufio.c diff = (long)b->c->block_size; block_size 383 drivers/md/dm-bufio.c if (c->block_size <= KMALLOC_MAX_SIZE && block_size 403 drivers/md/dm-bufio.c void *ptr = __vmalloc(c->block_size, gfp_mask, PAGE_KERNEL); block_size 409 drivers/md/dm-bufio.c return __vmalloc(c->block_size, gfp_mask, PAGE_KERNEL); block_size 599 drivers/md/dm-bufio.c vec_size = b->c->block_size >> PAGE_SHIFT; block_size 645 drivers/md/dm-bufio.c sector = b->block * (b->c->block_size >> SECTOR_SHIFT); block_size 649 drivers/md/dm-bufio.c n_sectors = b->c->block_size >> SECTOR_SHIFT; block_size 659 drivers/md/dm-bufio.c if (unlikely(end > b->c->block_size)) block_size 660 drivers/md/dm-bufio.c end = b->c->block_size; block_size 1185 drivers/md/dm-bufio.c BUG_ON(end > b->c->block_size); block_size 1208 drivers/md/dm-bufio.c dm_bufio_mark_partial_buffer_dirty(b, 0, b->c->block_size); block_size 1375 drivers/md/dm-bufio.c b->dirty_end = c->block_size; block_size 1434 drivers/md/dm-bufio.c return c->block_size; block_size 1444 drivers/md/dm-bufio.c sector_div(s, c->block_size >> SECTOR_SHIFT); block_size 1548 drivers/md/dm-bufio.c retain_bytes /= c->block_size; block_size 1605 drivers/md/dm-bufio.c struct dm_bufio_client *dm_bufio_client_create(struct block_device *bdev, unsigned block_size, block_size 1615 drivers/md/dm-bufio.c if (!block_size || block_size & ((1 << SECTOR_SHIFT) - 1)) { block_size 1629 drivers/md/dm-bufio.c c->block_size = block_size; block_size 1630 drivers/md/dm-bufio.c if (is_power_of_2(block_size)) block_size 1631 drivers/md/dm-bufio.c c->sectors_per_block_bits = __ffs(block_size) - SECTOR_SHIFT; block_size 1658 drivers/md/dm-bufio.c if (block_size <= KMALLOC_MAX_SIZE && block_size 1659 drivers/md/dm-bufio.c (block_size < PAGE_SIZE || !is_power_of_2(block_size))) { block_size 1660 drivers/md/dm-bufio.c unsigned align = min(1U << __ffs(block_size), (unsigned)PAGE_SIZE); block_size 1661 drivers/md/dm-bufio.c snprintf(slab_name, sizeof slab_name, "dm_bufio_cache-%u", block_size); block_size 1662 drivers/md/dm-bufio.c c->slab_cache = kmem_cache_create(slab_name, block_size, align, block_size 143 drivers/md/dm-cache-policy-internal.h sector_t origin_size, sector_t block_size); block_size 178 drivers/md/dm-cache-policy.h sector_t block_size); block_size 2085 drivers/md/dm-cache-target.c uint32_t block_size; block_size 2189 drivers/md/dm-cache-target.c unsigned long block_size; block_size 2194 drivers/md/dm-cache-target.c if (kstrtoul(dm_shift_arg(as), 10, &block_size) || !block_size || block_size 2195 drivers/md/dm-cache-target.c block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS || block_size 2196 drivers/md/dm-cache-target.c block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS || block_size 2197 drivers/md/dm-cache-target.c block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) { block_size 2202 drivers/md/dm-cache-target.c if (block_size > ca->cache_sectors) { block_size 2207 drivers/md/dm-cache-target.c ca->block_size = block_size; block_size 2505 drivers/md/dm-cache-target.c origin_blocks = block_div(origin_blocks, ca->block_size); block_size 2508 drivers/md/dm-cache-target.c cache->sectors_per_block = ca->block_size; block_size 2514 drivers/md/dm-cache-target.c if (ca->block_size & (ca->block_size - 1)) { block_size 2518 drivers/md/dm-cache-target.c cache_size = block_div(cache_size, ca->block_size); block_size 2521 drivers/md/dm-cache-target.c cache->sectors_per_block_shift = __ffs(ca->block_size); block_size 2539 drivers/md/dm-cache-target.c ca->block_size, may_format, block_size 2916 drivers/md/dm-cache-target.c dm_block_t block_size; block_size 2937 drivers/md/dm-cache-target.c b = li->discard_begin * li->block_size; block_size 2938 drivers/md/dm-cache-target.c e = li->discard_end * li->block_size; block_size 2962 drivers/md/dm-cache-target.c li->block_size = discard_block_size; block_size 266 drivers/md/dm-era-target.c dm_block_t block_size; block_size 500 drivers/md/dm-era-target.c disk->data_block_size = cpu_to_le32(md->block_size); block_size 578 drivers/md/dm-era-target.c md->block_size = le32_to_cpu(disk->data_block_size); block_size 778 drivers/md/dm-era-target.c sector_t block_size, block_size 788 drivers/md/dm-era-target.c md->block_size = block_size; block_size 1412 drivers/md/dm-era-target.c static bool valid_block_size(dm_block_t block_size) block_size 1414 drivers/md/dm-era-target.c bool greater_than_zero = block_size > 0; block_size 1415 drivers/md/dm-era-target.c bool multiple_of_min_block_size = (block_size & (MIN_BLOCK_SIZE - 1)) == 0; block_size 250 drivers/md/dm-thin-metadata.c size_t block_size) block_size 256 drivers/md/dm-thin-metadata.c block_size - sizeof(__le32), block_size 262 drivers/md/dm-thin-metadata.c size_t block_size) block_size 282 drivers/md/dm-thin-metadata.c block_size - sizeof(__le32), block_size 431 drivers/md/dm-thin-metadata.c unsigned block_size = dm_bm_block_size(bm) / sizeof(__le64); block_size 442 drivers/md/dm-thin-metadata.c for (i = 0; i < block_size; i++) { block_size 2846 drivers/md/dm-thin.c static bool is_factor(sector_t block_size, uint32_t n) block_size 2848 drivers/md/dm-thin.c return !sector_div(block_size, n); block_size 2950 drivers/md/dm-thin.c unsigned long block_size, block_size 2959 drivers/md/dm-thin.c pmd = dm_pool_metadata_open(metadata_dev, block_size, format_device); block_size 2973 drivers/md/dm-thin.c pool->sectors_per_block = block_size; block_size 2974 drivers/md/dm-thin.c if (block_size & (block_size - 1)) block_size 2977 drivers/md/dm-thin.c pool->sectors_per_block_shift = __ffs(block_size); block_size 3100 drivers/md/dm-thin.c unsigned long block_size, int read_only, block_size 3126 drivers/md/dm-thin.c pool = pool_create(pool_md, metadata_dev, data_dev, block_size, read_only, error); block_size 3308 drivers/md/dm-thin.c unsigned long block_size; block_size 3358 drivers/md/dm-thin.c if (kstrtoul(argv[2], 10, &block_size) || !block_size || block_size 3359 drivers/md/dm-thin.c block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS || block_size 3360 drivers/md/dm-thin.c block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS || block_size 3361 drivers/md/dm-thin.c block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) { block_size 3380 drivers/md/dm-thin.c block_size, pf.mode == PM_READ_ONLY, &ti->error, &pool_created); block_size 67 drivers/md/dm-writecache.c __le32 block_size; block_size 147 drivers/md/dm-writecache.c unsigned block_size; block_size 698 drivers/md/dm-writecache.c writecache_flush_region(wc, memory_data(wc, e), wc->block_size); block_size 1072 drivers/md/dm-writecache.c unsigned remaining_size = wc->block_size; block_size 1175 drivers/md/dm-writecache.c (wc->block_size / 512 - 1)) != 0)) { block_size 1178 drivers/md/dm-writecache.c bio->bi_iter.bi_size, wc->block_size); block_size 1204 drivers/md/dm-writecache.c dm_accept_partial_bio(bio, wc->block_size >> SECTOR_SHIFT); block_size 1246 drivers/md/dm-writecache.c dm_accept_partial_bio(bio, wc->block_size >> SECTOR_SHIFT); block_size 1319 drivers/md/dm-writecache.c if (limits->logical_block_size < wc->block_size) block_size 1320 drivers/md/dm-writecache.c limits->logical_block_size = wc->block_size; block_size 1322 drivers/md/dm-writecache.c if (limits->physical_block_size < wc->block_size) block_size 1323 drivers/md/dm-writecache.c limits->physical_block_size = wc->block_size; block_size 1325 drivers/md/dm-writecache.c if (limits->io_min < wc->block_size) block_size 1326 drivers/md/dm-writecache.c limits->io_min = wc->block_size; block_size 1475 drivers/md/dm-writecache.c unsigned block_size = wc->block_size; block_size 1478 drivers/md/dm-writecache.c persistent_memory_flush_cache(address, block_size); block_size 1480 drivers/md/dm-writecache.c block_size, persistent_memory_page_offset(address)) != 0; block_size 1537 drivers/md/dm-writecache.c read_original_sector(wc, e) + (wc->block_size >> SECTOR_SHIFT)) block_size 1585 drivers/md/dm-writecache.c while ((n_sectors -= wc->block_size >> SECTOR_SHIFT)) { block_size 1684 drivers/md/dm-writecache.c read_original_sector(wc, f) + (wc->block_size >> SECTOR_SHIFT)) block_size 1748 drivers/md/dm-writecache.c static int calculate_memory_size(uint64_t device_size, unsigned block_size, block_size 1755 drivers/md/dm-writecache.c do_div(n_blocks, block_size + sizeof(struct wc_memory_entry)); block_size 1765 drivers/md/dm-writecache.c offset = (offset + block_size - 1) & ~(uint64_t)(block_size - 1); block_size 1766 drivers/md/dm-writecache.c if (offset + n_blocks * block_size <= device_size) block_size 1779 drivers/md/dm-writecache.c *n_metadata_blocks_p = offset >> __ffs(block_size); block_size 1788 drivers/md/dm-writecache.c r = calculate_memory_size(wc->memory_map_size, wc->block_size, &wc->n_blocks, NULL); block_size 1799 drivers/md/dm-writecache.c pmem_assign(sb(wc)->block_size, cpu_to_le32(wc->block_size)); block_size 2008 drivers/md/dm-writecache.c if (sscanf(string, "%u%c", &wc->block_size, &dummy) != 1 || block_size 2009 drivers/md/dm-writecache.c wc->block_size < 512 || wc->block_size > PAGE_SIZE || block_size 2010 drivers/md/dm-writecache.c (wc->block_size & (wc->block_size - 1))) { block_size 2015 drivers/md/dm-writecache.c if (wc->block_size < bdev_logical_block_size(wc->dev->bdev) || block_size 2016 drivers/md/dm-writecache.c wc->block_size < bdev_logical_block_size(wc->ssd_dev->bdev)) { block_size 2021 drivers/md/dm-writecache.c wc->block_size_bits = __ffs(wc->block_size); block_size 2124 drivers/md/dm-writecache.c r = calculate_memory_size(wc->memory_map_size, wc->block_size, block_size 2165 drivers/md/dm-writecache.c r = writecache_read_metadata(wc, wc->block_size >> SECTOR_SHIFT); block_size 2202 drivers/md/dm-writecache.c if (le32_to_cpu(s.block_size) != wc->block_size) { block_size 2220 drivers/md/dm-writecache.c offset = (offset + wc->block_size - 1) & ~(size_t)(wc->block_size - 1); block_size 2221 drivers/md/dm-writecache.c data_size = wc->n_blocks * (size_t)wc->block_size; block_size 2222 drivers/md/dm-writecache.c if (!offset || (data_size / wc->block_size != wc->n_blocks) || block_size 2282 drivers/md/dm-writecache.c wc->dev->name, wc->ssd_dev->name, wc->block_size); block_size 379 drivers/md/persistent-data/dm-block-manager.c unsigned block_size, block_size 391 drivers/md/persistent-data/dm-block-manager.c bm->bufio = dm_bufio_client_create(bdev, block_size, max_held_per_thread, block_size 35 drivers/md/persistent-data/dm-block-manager.h struct block_device *bdev, unsigned block_size, block_size 52 drivers/md/persistent-data/dm-block-manager.h void (*prepare_for_write)(struct dm_block_validator *v, struct dm_block *b, size_t block_size); block_size 57 drivers/md/persistent-data/dm-block-manager.h int (*check)(struct dm_block_validator *v, struct dm_block *b, size_t block_size); block_size 20 drivers/md/persistent-data/dm-btree-spine.c size_t block_size); block_size 24 drivers/md/persistent-data/dm-btree-spine.c size_t block_size) block_size 31 drivers/md/persistent-data/dm-btree-spine.c block_size - sizeof(__le32), block_size 39 drivers/md/persistent-data/dm-btree-spine.c size_t block_size) block_size 54 drivers/md/persistent-data/dm-btree-spine.c block_size - sizeof(__le32), block_size 65 drivers/md/persistent-data/dm-btree-spine.c (sizeof(__le64) + value_size) * le32_to_cpu(h->max_entries) > block_size) { block_size 114 drivers/md/persistent-data/dm-btree.c static uint32_t calc_max_entries(size_t value_size, size_t block_size) block_size 119 drivers/md/persistent-data/dm-btree.c block_size -= sizeof(struct node_header); block_size 120 drivers/md/persistent-data/dm-btree.c total = block_size / elt_size; block_size 131 drivers/md/persistent-data/dm-btree.c size_t block_size; block_size 138 drivers/md/persistent-data/dm-btree.c block_size = dm_bm_block_size(dm_tm_get_bm(info->tm)); block_size 139 drivers/md/persistent-data/dm-btree.c max_entries = calc_max_entries(info->value_type.size, block_size); block_size 142 drivers/md/persistent-data/dm-btree.c memset(n, 0, block_size); block_size 24 drivers/md/persistent-data/dm-space-map-common.c size_t block_size) block_size 30 drivers/md/persistent-data/dm-space-map-common.c block_size - sizeof(__le32), block_size 36 drivers/md/persistent-data/dm-space-map-common.c size_t block_size) block_size 48 drivers/md/persistent-data/dm-space-map-common.c block_size - sizeof(__le32), block_size 74 drivers/md/persistent-data/dm-space-map-common.c size_t block_size) block_size 80 drivers/md/persistent-data/dm-space-map-common.c block_size - sizeof(__le32), block_size 86 drivers/md/persistent-data/dm-space-map-common.c size_t block_size) block_size 98 drivers/md/persistent-data/dm-space-map-common.c block_size - sizeof(__le32), block_size 217 drivers/md/persistent-data/dm-space-map-common.c ll->block_size = dm_bm_block_size(dm_tm_get_bm(tm)); block_size 219 drivers/md/persistent-data/dm-space-map-common.c if (ll->block_size > (1 << 30)) { block_size 224 drivers/md/persistent-data/dm-space-map-common.c ll->entries_per_block = (ll->block_size - sizeof(struct disk_bitmap_header)) * block_size 62 drivers/md/persistent-data/dm-space-map-common.h uint32_t block_size; block_size 94 drivers/md/raid5-ppl.c int block_size; /* the logical block size used for data_sector block_size 453 drivers/md/raid5-ppl.c ilog2(ppl_conf->block_size >> 9)); block_size 801 drivers/md/raid5-ppl.c int block_size = ppl_conf->block_size; block_size 822 drivers/md/raid5-ppl.c r_sector_first = le64_to_cpu(e->data_sector) * (block_size >> 9); block_size 846 drivers/md/raid5-ppl.c if (block_size == 512 && block_size 849 drivers/md/raid5-ppl.c block_size = STRIPE_SIZE; block_size 852 drivers/md/raid5-ppl.c for (i = 0; i < strip_sectors; i += (block_size >> 9)) { block_size 907 drivers/md/raid5-ppl.c if (!sync_page_io(rdev, sector, block_size, page2, block_size 916 drivers/md/raid5-ppl.c ppl_xor(block_size, page1, page2); block_size 930 drivers/md/raid5-ppl.c block_size, page2, REQ_OP_READ, 0, block_size 939 drivers/md/raid5-ppl.c ppl_xor(block_size, page1, page2); block_size 953 drivers/md/raid5-ppl.c if (!sync_page_io(parity_rdev, parity_sector, block_size, block_size 1411 drivers/md/raid5-ppl.c ppl_conf->block_size = 512; block_size 1413 drivers/md/raid5-ppl.c ppl_conf->block_size = queue_logical_block_size(mddev->queue); block_size 1600 drivers/media/dvb-frontends/drx39xyj/drxj.c u16 block_size = 0; block_size 1623 drivers/media/dvb-frontends/drx39xyj/drxj.c block_size = ((DRXDAP_MAX_WCHUNKSIZE) - overhead_size) & ~1; block_size 1662 drivers/media/dvb-frontends/drx39xyj/drxj.c todo = (block_size < datasize ? block_size : datasize); block_size 424 drivers/media/dvb-frontends/drxk_hard.c const int block_size, const u8 p_block[]) block_size 426 drivers/media/dvb-frontends/drxk_hard.c int status = 0, blk_size = block_size; block_size 1311 drivers/media/dvb-frontends/drxk_hard.c u16 block_size; block_size 1335 drivers/media/dvb-frontends/drxk_hard.c block_size = ((p_src[0] << 8) | p_src[1]) * sizeof(u16); block_size 1353 drivers/media/dvb-frontends/drxk_hard.c if (offset + block_size > length) { block_size 1358 drivers/media/dvb-frontends/drxk_hard.c status = write_block(state, address, block_size, p_src); block_size 1363 drivers/media/dvb-frontends/drxk_hard.c p_src += block_size; block_size 1364 drivers/media/dvb-frontends/drxk_hard.c offset += block_size; block_size 859 drivers/media/dvb-frontends/mxl5xx.c u32 block_size = ((MXL_HYDRA_OEM_MAX_BLOCK_WRITE_LENGTH - block_size 866 drivers/media/dvb-frontends/mxl5xx.c size = orig_size = (((u32)(data_count + block_size)) > total_size) ? block_size 867 drivers/media/dvb-frontends/mxl5xx.c (total_size - data_count) : block_size; block_size 36 drivers/media/usb/gspca/jl2005bcd.c int block_size; /* block size of camera */ block_size 349 drivers/media/usb/gspca/jl2005bcd.c bytes_left = buffer[0x07] * dev->block_size - act_len; block_size 420 drivers/media/usb/gspca/jl2005bcd.c sd->block_size = 0x80; block_size 424 drivers/media/usb/gspca/jl2005bcd.c sd->block_size = 0x200; block_size 978 drivers/memstick/core/ms_block.c sg_init_one(&sg, msb->block_buffer, msb->block_size); block_size 990 drivers/memstick/core/ms_block.c msb->block_buffer, msb->block_size)) block_size 1172 drivers/memstick/core/ms_block.c p->attr.block_size = be16_to_cpu(p->attr.block_size); block_size 1518 drivers/memstick/core/ms_block.c msb->cache = kzalloc(msb->block_size, GFP_KERNEL); block_size 1545 drivers/memstick/core/ms_block.c sg_init_one(&sg, msb->cache , msb->block_size); block_size 1727 drivers/memstick/core/ms_block.c msb->pages_in_block = boot_block->attr.block_size * 2; block_size 1728 drivers/memstick/core/ms_block.c msb->block_size = msb->page_size * msb->pages_in_block; block_size 1736 drivers/memstick/core/ms_block.c msb->block_buffer = kzalloc(msb->block_size, GFP_KERNEL); block_size 1740 drivers/memstick/core/ms_block.c raw_size_in_megs = (msb->block_size * msb->block_count) >> 20; block_size 1810 drivers/memstick/core/ms_block.c if (page == 0 && len - offset >= msb->block_size) { block_size 1820 drivers/memstick/core/ms_block.c offset += msb->block_size; block_size 1821 drivers/memstick/core/ms_block.c *sucessfuly_written += msb->block_size; block_size 2260 drivers/memstick/core/ms_block.c if (msb->block_size != new_msb->block_size) block_size 76 drivers/memstick/core/ms_block.h unsigned short block_size; block_size 171 drivers/memstick/core/ms_block.h int block_size; block_size 71 drivers/memstick/core/mspro_block.c __be16 block_size; block_size 335 drivers/memstick/core/mspro_block.c be16_to_cpu(x_sys->block_size)); block_size 1241 drivers/memstick/core/mspro_block.c capacity *= be16_to_cpu(sys_info->block_size); block_size 102 drivers/misc/c2port/c2port-duramar2150.c .block_size = 512, /* bytes */ block_size 328 drivers/misc/c2port/core.c return sprintf(buf, "%d\n", ops->block_size); block_size 338 drivers/misc/c2port/core.c return sprintf(buf, "%d\n", ops->blocks_num * ops->block_size); block_size 634 drivers/misc/c2port/core.c if (offset >= ops->block_size * ops->blocks_num) block_size 637 drivers/misc/c2port/core.c if (ops->block_size * ops->blocks_num - offset < nread) block_size 638 drivers/misc/c2port/core.c nread = ops->block_size * ops->blocks_num - offset; block_size 746 drivers/misc/c2port/core.c if (ops->block_size * ops->blocks_num - offset < nwrite) block_size 747 drivers/misc/c2port/core.c nwrite = ops->block_size * ops->blocks_num - offset; block_size 750 drivers/misc/c2port/core.c if (offset >= ops->block_size * ops->blocks_num) block_size 916 drivers/misc/c2port/core.c bin_attr_flash_data.size = ops->blocks_num * ops->block_size; block_size 937 drivers/misc/c2port/core.c name, ops->blocks_num, ops->block_size, block_size 938 drivers/misc/c2port/core.c ops->blocks_num * ops->block_size); block_size 356 drivers/mmc/core/queue.c unsigned block_size = 512; block_size 374 drivers/mmc/core/queue.c block_size = card->ext_csd.data_sector_size; block_size 376 drivers/mmc/core/queue.c blk_queue_logical_block_size(mq->queue, block_size); block_size 384 drivers/mmc/core/queue.c round_down(host->max_seg_size, block_size)); block_size 358 drivers/mmc/host/android-goldfish.c int block_size; block_size 370 drivers/mmc/host/android-goldfish.c block_size = data->blksz; block_size 373 drivers/mmc/host/android-goldfish.c GOLDFISH_MMC_WRITE(host, MMC_BLOCK_LENGTH, block_size - 1); block_size 947 drivers/mmc/host/omap.c int i, use_dma = 1, block_size; block_size 961 drivers/mmc/host/omap.c block_size = data->blksz; block_size 964 drivers/mmc/host/omap.c OMAP_MMC_WRITE(host, BLEN, block_size - 1); block_size 974 drivers/mmc/host/omap.c if ((sg->length % block_size) != 0) { block_size 1059 drivers/mmc/host/omap.c host->total_bytes_left = data->blocks * block_size; block_size 66 drivers/mmc/host/ushc.c __le16 block_size; block_size 279 drivers/mmc/host/ushc.c ushc->cbw->block_size = cpu_to_le16(req->data->blksz); block_size 281 drivers/mmc/host/ushc.c ushc->cbw->block_size = 0; block_size 70 drivers/mmc/host/vub300.c u8 block_size[2]; block_size 1080 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[0] = (vub300->fbs[fn] >> 8) & 0xFF; block_size 1081 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[1] = (vub300->fbs[fn] >> 0) & 0xFF; block_size 1090 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[0] = (vub300->fbs[0] >> 8) & 0xFF; block_size 1091 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[1] = (vub300->fbs[0] >> 0) & 0xFF; block_size 1104 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[0] = block_size 1106 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[1] = block_size 1111 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[0] = block_size 1113 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[1] = block_size 1133 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[0] = (data->blksz >> 8) & 0xFF; block_size 1134 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[1] = (data->blksz >> 0) & 0xFF; block_size 1150 drivers/mmc/host/vub300.c if (vub300->cmnd.head.block_size[0] || vub300->cmnd.head.block_size[1]) { block_size 1151 drivers/mmc/host/vub300.c u16 block_size = vub300->cmnd.head.block_size[1] | block_size 1152 drivers/mmc/host/vub300.c (vub300->cmnd.head.block_size[0] << 8); block_size 1154 drivers/mmc/host/vub300.c (FIRMWARE_BLOCK_BOUNDARY % block_size); block_size 2181 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[0] = 0x00; block_size 2182 drivers/mmc/host/vub300.c vub300->cmnd.head.block_size[1] = 0x00; block_size 2132 drivers/mtd/nand/onenand/onenand_base.c unsigned int block_size = (1 << this->erase_shift); block_size 2136 drivers/mtd/nand/onenand/onenand_base.c this->command(mtd, ONENAND_CMD_ERASE_VERIFY, addr, block_size); block_size 2144 drivers/mtd/nand/onenand/onenand_base.c len -= block_size; block_size 2145 drivers/mtd/nand/onenand/onenand_base.c addr += block_size; block_size 2160 drivers/mtd/nand/onenand/onenand_base.c unsigned int block_size) block_size 2184 drivers/mtd/nand/onenand/onenand_base.c len -= block_size; block_size 2185 drivers/mtd/nand/onenand/onenand_base.c addr += block_size; block_size 2211 drivers/mtd/nand/onenand/onenand_base.c while (len > block_size && eb_count < (max_eb_count - 1)) { block_size 2213 drivers/mtd/nand/onenand/onenand_base.c addr, block_size); block_size 2214 drivers/mtd/nand/onenand/onenand_base.c onenand_invalidate_bufferram(mtd, addr, block_size); block_size 2225 drivers/mtd/nand/onenand/onenand_base.c len -= block_size; block_size 2226 drivers/mtd/nand/onenand/onenand_base.c addr += block_size; block_size 2232 drivers/mtd/nand/onenand/onenand_base.c this->command(mtd, ONENAND_CMD_ERASE, addr, block_size); block_size 2233 drivers/mtd/nand/onenand/onenand_base.c onenand_invalidate_bufferram(mtd, addr, block_size); block_size 2244 drivers/mtd/nand/onenand/onenand_base.c len -= block_size; block_size 2245 drivers/mtd/nand/onenand/onenand_base.c addr += block_size; block_size 2249 drivers/mtd/nand/onenand/onenand_base.c verify_instr.len = eb_count * block_size; block_size 2272 drivers/mtd/nand/onenand/onenand_base.c unsigned int block_size) block_size 2297 drivers/mtd/nand/onenand/onenand_base.c this->command(mtd, ONENAND_CMD_ERASE, addr, block_size); block_size 2299 drivers/mtd/nand/onenand/onenand_base.c onenand_invalidate_bufferram(mtd, addr, block_size); block_size 2310 drivers/mtd/nand/onenand/onenand_base.c len -= block_size; block_size 2311 drivers/mtd/nand/onenand/onenand_base.c addr += block_size; block_size 2318 drivers/mtd/nand/onenand/onenand_base.c block_size = region->erasesize; block_size 2321 drivers/mtd/nand/onenand/onenand_base.c if (len & (block_size - 1)) { block_size 2342 drivers/mtd/nand/onenand/onenand_base.c unsigned int block_size; block_size 2358 drivers/mtd/nand/onenand/onenand_base.c block_size = region->erasesize; block_size 2365 drivers/mtd/nand/onenand/onenand_base.c block_size = 1 << this->erase_shift; block_size 2368 drivers/mtd/nand/onenand/onenand_base.c if (unlikely((addr - region_offset) & (block_size - 1))) { block_size 2374 drivers/mtd/nand/onenand/onenand_base.c if (unlikely(len & (block_size - 1))) { block_size 2383 drivers/mtd/nand/onenand/onenand_base.c instr->len < MB_ERASE_MIN_BLK_COUNT * block_size) { block_size 2386 drivers/mtd/nand/onenand/onenand_base.c region, block_size); block_size 2388 drivers/mtd/nand/onenand/onenand_base.c ret = onenand_multiblock_erase(mtd, instr, block_size); block_size 212 drivers/mtd/nand/raw/brcmnand/brcmnand.c unsigned int block_size; block_size 2082 drivers/mtd/nand/raw/brcmnand/brcmnand.c u8 block_size = 0, page_size = 0, device_size = 0; block_size 2089 drivers/mtd/nand/raw/brcmnand/brcmnand.c if (ctrl->block_sizes[i] * 1024 == cfg->block_size) { block_size 2090 drivers/mtd/nand/raw/brcmnand/brcmnand.c block_size = i; block_size 2095 drivers/mtd/nand/raw/brcmnand/brcmnand.c cfg->block_size); block_size 2099 drivers/mtd/nand/raw/brcmnand/brcmnand.c block_size = ffs(cfg->block_size) - ffs(BRCMNAND_MIN_BLOCKSIZE); block_size 2102 drivers/mtd/nand/raw/brcmnand/brcmnand.c if (cfg->block_size < BRCMNAND_MIN_BLOCKSIZE || (ctrl->max_block_size && block_size 2103 drivers/mtd/nand/raw/brcmnand/brcmnand.c cfg->block_size > ctrl->max_block_size)) { block_size 2105 drivers/mtd/nand/raw/brcmnand/brcmnand.c cfg->block_size); block_size 2106 drivers/mtd/nand/raw/brcmnand/brcmnand.c block_size = 0; block_size 2146 drivers/mtd/nand/raw/brcmnand/brcmnand.c (block_size << CFG_BLK_SIZE_SHIFT); block_size 2151 drivers/mtd/nand/raw/brcmnand/brcmnand.c (block_size << CFG_EXT_BLK_SIZE_SHIFT); block_size 2176 drivers/mtd/nand/raw/brcmnand/brcmnand.c cfg->block_size >> 10, block_size 2233 drivers/mtd/nand/raw/brcmnand/brcmnand.c cfg->block_size = mtd->erasesize; block_size 1436 drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c unsigned int block_size = geo->ecc_chunk_size; block_size 1443 drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c BF_BCH_FLASH0LAYOUT0_DATA0_SIZE(block_size, this); block_size 1449 drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c BF_BCH_FLASH0LAYOUT1_DATAN_SIZE(block_size, this); block_size 26 drivers/mtd/rfd_ftl.c static int block_size = 0; block_size 27 drivers/mtd/rfd_ftl.c module_param(block_size, int, 0); block_size 28 drivers/mtd/rfd_ftl.c MODULE_PARM_DESC(block_size, "Block size to use by RFD, defaults to erase unit size"); block_size 74 drivers/mtd/rfd_ftl.c u_int block_size; /* size of erase unit */ block_size 98 drivers/mtd/rfd_ftl.c block->offset = part->block_size * block_no; block_size 158 drivers/mtd/rfd_ftl.c sectors_per_block = part->block_size / SECTOR_SIZE; block_size 159 drivers/mtd/rfd_ftl.c part->total_blocks = (u32)part->mbd.mtd->size / part->block_size; block_size 205 drivers/mtd/rfd_ftl.c rc = mtd_read(part->mbd.mtd, i * part->block_size, block_size 281 drivers/mtd/rfd_ftl.c erase->len = part->block_size; block_size 421 drivers/mtd/rfd_ftl.c old_sector_block = *old_sector / part->block_size; block_size 555 drivers/mtd/rfd_ftl.c block = old_addr / part->block_size; block_size 556 drivers/mtd/rfd_ftl.c offset = (old_addr % part->block_size) / SECTOR_SIZE - block_size 735 drivers/mtd/rfd_ftl.c if (block_size) block_size 736 drivers/mtd/rfd_ftl.c part->block_size = block_size; block_size 742 drivers/mtd/rfd_ftl.c part->block_size = mtd->erasesize; block_size 197 drivers/mtd/sm_ftl.c WARN_ON(boffset >= ftl->block_size); block_size 202 drivers/mtd/sm_ftl.c return (zone * SM_MAX_ZONE_SIZE + block) * ftl->block_size + boffset; block_size 210 drivers/mtd/sm_ftl.c *boffset = do_div(offset, ftl->block_size); block_size 382 drivers/mtd/sm_ftl.c for (boffset = 0; boffset < ftl->block_size; block_size 451 drivers/mtd/sm_ftl.c for (boffset = 0; boffset < ftl->block_size; boffset += SM_SECTOR_SIZE) block_size 467 drivers/mtd/sm_ftl.c erase.len = ftl->block_size; block_size 508 drivers/mtd/sm_ftl.c for (boffset = 0; boffset < ftl->block_size; block_size 573 drivers/mtd/sm_ftl.c ftl->block_size = 8 * SM_SECTOR_SIZE; block_size 582 drivers/mtd/sm_ftl.c ftl->block_size = 8 * SM_SECTOR_SIZE; block_size 592 drivers/mtd/sm_ftl.c ftl->block_size = 16 * SM_SECTOR_SIZE; block_size 599 drivers/mtd/sm_ftl.c ftl->block_size = 16 * SM_SECTOR_SIZE; block_size 605 drivers/mtd/sm_ftl.c ftl->block_size = 16 * SM_SECTOR_SIZE; block_size 614 drivers/mtd/sm_ftl.c ftl->block_size = 32 * SM_SECTOR_SIZE; block_size 618 drivers/mtd/sm_ftl.c if (mtd->erasesize > ftl->block_size) block_size 695 drivers/mtd/sm_ftl.c for (boffset = 0 ; boffset < ftl->block_size; block_size 706 drivers/mtd/sm_ftl.c if (boffset == ftl->block_size) block_size 722 drivers/mtd/sm_ftl.c block * ftl->block_size + block_size 939 drivers/mtd/sm_ftl.c ftl->block_size / SM_SECTOR_SIZE) { block_size 1152 drivers/mtd/sm_ftl.c ftl->cache_data = kzalloc(ftl->block_size, GFP_KERNEL); block_size 1171 drivers/mtd/sm_ftl.c trans->size = (ftl->block_size * ftl->max_lba * ftl->zone_count) >> 9; block_size 1192 drivers/mtd/sm_ftl.c ftl->block_size); block_size 32 drivers/mtd/sm_ftl.h int block_size; /* block size in bytes */ block_size 610 drivers/mtd/spi-nor/intel-spi.c size_t block_size, retlen = 0; block_size 632 drivers/mtd/spi-nor/intel-spi.c block_size = min_t(size_t, len, INTEL_SPI_FIFO_SZ); block_size 635 drivers/mtd/spi-nor/intel-spi.c block_size = min_t(loff_t, from + block_size, block_size 643 drivers/mtd/spi-nor/intel-spi.c val |= (block_size - 1) << HSFSTS_CTL_FDBC_SHIFT; block_size 664 drivers/mtd/spi-nor/intel-spi.c ret = intel_spi_read_block(ispi, read_buf, block_size); block_size 668 drivers/mtd/spi-nor/intel-spi.c len -= block_size; block_size 669 drivers/mtd/spi-nor/intel-spi.c from += block_size; block_size 670 drivers/mtd/spi-nor/intel-spi.c retlen += block_size; block_size 671 drivers/mtd/spi-nor/intel-spi.c read_buf += block_size; block_size 681 drivers/mtd/spi-nor/intel-spi.c size_t block_size, retlen = 0; block_size 689 drivers/mtd/spi-nor/intel-spi.c block_size = min_t(size_t, len, INTEL_SPI_FIFO_SZ); block_size 692 drivers/mtd/spi-nor/intel-spi.c block_size = min_t(loff_t, to + block_size, block_size 700 drivers/mtd/spi-nor/intel-spi.c val |= (block_size - 1) << HSFSTS_CTL_FDBC_SHIFT; block_size 703 drivers/mtd/spi-nor/intel-spi.c ret = intel_spi_write_block(ispi, write_buf, block_size); block_size 731 drivers/mtd/spi-nor/intel-spi.c len -= block_size; block_size 732 drivers/mtd/spi-nor/intel-spi.c to += block_size; block_size 733 drivers/mtd/spi-nor/intel-spi.c retlen += block_size; block_size 734 drivers/mtd/spi-nor/intel-spi.c write_buf += block_size; block_size 101 drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c u16 block_size; block_size 145 drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c block_size = (u16) min_t(u32, comp->data_size - offset, block_size 148 drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c block_ptr, block_size, block_size 153 drivers/net/ethernet/mellanox/mlxfw/mlxfw_fsm.c comp_name, offset + block_size, block_size 77 drivers/net/ethernet/mellanox/mlxsw/i2c.c u16 block_size; block_size 326 drivers/net/ethernet/mellanox/mlxsw/i2c.c tran_buf = kmalloc(mlxsw_i2c->block_size + MLXSW_I2C_ADDR_BUF_SIZE, block_size 333 drivers/net/ethernet/mellanox/mlxsw/i2c.c chunk_size = (in_mbox_size > mlxsw_i2c->block_size) ? block_size 334 drivers/net/ethernet/mellanox/mlxsw/i2c.c mlxsw_i2c->block_size : in_mbox_size; block_size 338 drivers/net/ethernet/mellanox/mlxsw/i2c.c mlxsw_i2c->block_size * i, chunk_size); block_size 409 drivers/net/ethernet/mellanox/mlxsw/i2c.c num = reg_size / mlxsw_i2c->block_size; block_size 410 drivers/net/ethernet/mellanox/mlxsw/i2c.c if (reg_size % mlxsw_i2c->block_size) block_size 430 drivers/net/ethernet/mellanox/mlxsw/i2c.c num = reg_size / mlxsw_i2c->block_size; block_size 446 drivers/net/ethernet/mellanox/mlxsw/i2c.c chunk_size = (reg_size > mlxsw_i2c->block_size) ? block_size 447 drivers/net/ethernet/mellanox/mlxsw/i2c.c mlxsw_i2c->block_size : reg_size; block_size 578 drivers/net/ethernet/mellanox/mlxsw/i2c.c mlxsw_i2c->block_size = max_t(u16, MLXSW_I2C_BLK_DEF, block_size 582 drivers/net/ethernet/mellanox/mlxsw/i2c.c mlxsw_i2c->block_size = MLXSW_I2C_BLK_DEF; block_size 1150 drivers/net/ethernet/neterion/vxge/vxge-config.c blockpool->block_size = VXGE_HW_BLOCK_SIZE; block_size 2353 drivers/net/ethernet/neterion/vxge/vxge-config.c if (size != blockpool->block_size) { block_size 2447 drivers/net/ethernet/neterion/vxge/vxge-config.c if (size != blockpool->block_size) { block_size 4768 drivers/net/ethernet/neterion/vxge/vxge-config.c if (size == blockpool->block_size) { block_size 4950 drivers/net/ethernet/neterion/vxge/vxge-config.c if (entry->length == blockpool->block_size) { block_size 554 drivers/net/ethernet/neterion/vxge/vxge-config.h u32 block_size; block_size 3690 drivers/net/ethernet/qlogic/qed/qed_debug.c u32 block_size, ram_size, offset = 0, reg_val, i; block_size 3699 drivers/net/ethernet/qlogic/qed/qed_debug.c block_size = reg_val & block_size 3713 drivers/net/ethernet/qlogic/qed/qed_debug.c block_size * 8, block_size 279 drivers/net/ethernet/qlogic/qlcnic/qlcnic.h u32 block_size; block_size 661 drivers/net/ethernet/sfc/falcon/falcon.c (spi->block_size - (start & (spi->block_size - 1)))); block_size 2168 drivers/net/ethernet/sfc/falcon/falcon.c spi_device->block_size = block_size 205 drivers/net/ethernet/sfc/falcon/nic.h unsigned int block_size; block_size 200 drivers/net/wireless/ath/ath10k/sdio.c ret = sdio_set_block_size(func, ar_sdio->mbox_info.block_size); block_size 203 drivers/net/wireless/ath/ath10k/sdio.c ar_sdio->mbox_info.block_size, ret); block_size 353 drivers/net/wireless/ath/ath10k/sdio.c len = round_down(len, ar_sdio->mbox_info.block_size); block_size 1036 drivers/net/wireless/ath/ath10k/sdio.c mbox_info->block_size = ATH10K_HIF_MBOX_BLOCK_SIZE; block_size 172 drivers/net/wireless/ath/ath10k/sdio.h u32 block_size; block_size 522 drivers/net/wireless/ath/ath6kl/core.h u32 block_size; block_size 680 drivers/net/wireless/ath/ath6kl/hif.c dev->htc_cnxt->block_sz = dev->ar->mbox_info.block_size; block_size 2786 drivers/net/wireless/ath/ath6kl/htc_mbox.c u32 block_size, ctrl_bufsz; block_size 2792 drivers/net/wireless/ath/ath6kl/htc_mbox.c block_size = target->dev->ar->mbox_info.block_size; block_size 2794 drivers/net/wireless/ath/ath6kl/htc_mbox.c ctrl_bufsz = (block_size > HTC_MAX_CTRL_MSG_LEN) ? block_size 2795 drivers/net/wireless/ath/ath6kl/htc_mbox.c (block_size + HTC_HDR_LENGTH) : block_size 422 drivers/net/wireless/ath/ath6kl/init.c blk_size = ar->mbox_info.block_size; block_size 104 drivers/net/wireless/ath/ath6kl/sdio.c mbox_info->block_size = HIF_MBOX_BLOCK_SIZE; block_size 1150 drivers/net/wireless/ath/ath6kl/usb.c ar->mbox_info.block_size = 16; block_size 79 drivers/net/wireless/intel/iwlwifi/fw/api/paging.h __le32 block_size; block_size 297 drivers/net/wireless/intel/iwlwifi/fw/paging.c .block_size = cpu_to_le32(BLOCK_2_EXP_SIZE), block_size 504 drivers/net/wireless/intersil/p54/p54usb.c unsigned int left, remains, block_size; block_size 516 drivers/net/wireless/intersil/p54/p54usb.c left = block_size = min_t(size_t, P54U_FW_BLOCK, priv->fw->size); block_size 558 drivers/net/wireless/intersil/p54/p54usb.c err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size); block_size 566 drivers/net/wireless/intersil/p54/p54usb.c left = block_size = min((unsigned int)P54U_FW_BLOCK, remains); block_size 1464 drivers/net/wireless/marvell/mwifiex/fw.h __le16 block_size; block_size 992 drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c adapter->sdio_rx_block_size = le16_to_cpu(cfg->block_size); block_size 661 drivers/net/wireless/marvell/mwl8k.c int block_size = length > 256 ? 256 : length; block_size 663 drivers/net/wireless/marvell/mwl8k.c memcpy(cmd->payload, data + done, block_size); block_size 664 drivers/net/wireless/marvell/mwl8k.c cmd->length = cpu_to_le16(block_size); block_size 667 drivers/net/wireless/marvell/mwl8k.c sizeof(*cmd) + block_size); block_size 671 drivers/net/wireless/marvell/mwl8k.c done += block_size; block_size 672 drivers/net/wireless/marvell/mwl8k.c length -= block_size; block_size 700 drivers/net/wireless/marvell/mwl8k.c u32 block_size; block_size 702 drivers/net/wireless/marvell/mwl8k.c block_size = ioread32(priv->regs + MWL8K_HIU_SCRATCH); block_size 703 drivers/net/wireless/marvell/mwl8k.c if (block_size & 1) { block_size 704 drivers/net/wireless/marvell/mwl8k.c block_size &= ~1; block_size 711 drivers/net/wireless/marvell/mwl8k.c if (block_size > 1024 || block_size > length) { block_size 721 drivers/net/wireless/marvell/mwl8k.c if (block_size == 0) { block_size 728 drivers/net/wireless/marvell/mwl8k.c prev_block_size = block_size; block_size 729 drivers/net/wireless/marvell/mwl8k.c memcpy(buffer, data + done, block_size); block_size 731 drivers/net/wireless/marvell/mwl8k.c rc = mwl8k_send_fw_load_cmd(priv, buffer, block_size); block_size 714 drivers/net/wireless/rsi/rsi_91x_hal.c u32 block_size = adapter->block_size; block_size 733 drivers/net/wireless/rsi/rsi_91x_hal.c block_size, addr); block_size 1008 drivers/net/wireless/rsi/rsi_91x_hal.c u16 block_size = adapter->block_size; block_size 1076 drivers/net/wireless/rsi/rsi_91x_hal.c block_size, block_size 1094 drivers/net/wireless/rsi/rsi_91x_hal.c block_size, block_size 373 drivers/net/wireless/rsi/rsi_91x_sdio.c adapter->block_size = dev->pfunction->max_blksize; block_size 572 drivers/net/wireless/rsi/rsi_91x_sdio.c u16 block_size, block_size 580 drivers/net/wireless/rsi/rsi_91x_sdio.c num_blocks = instructions_sz / block_size; block_size 586 drivers/net/wireless/rsi/rsi_91x_sdio.c temp_buf = kmalloc(block_size, GFP_KERNEL); block_size 597 drivers/net/wireless/rsi/rsi_91x_sdio.c for (offset = 0, i = 0; i < num_blocks; i++, offset += block_size) { block_size 598 drivers/net/wireless/rsi/rsi_91x_sdio.c memcpy(temp_buf, ta_firmware + offset, block_size); block_size 603 drivers/net/wireless/rsi/rsi_91x_sdio.c temp_buf, block_size); block_size 609 drivers/net/wireless/rsi/rsi_91x_sdio.c base_address += block_size; block_size 626 drivers/net/wireless/rsi/rsi_91x_sdio.c if (instructions_sz % block_size) { block_size 627 drivers/net/wireless/rsi/rsi_91x_sdio.c memset(temp_buf, 0, block_size); block_size 629 drivers/net/wireless/rsi/rsi_91x_sdio.c instructions_sz % block_size); block_size 635 drivers/net/wireless/rsi/rsi_91x_sdio.c instructions_sz % block_size); block_size 772 drivers/net/wireless/rsi/rsi_91x_sdio.c u32 block_size = dev->tx_blk_size; block_size 781 drivers/net/wireless/rsi/rsi_91x_sdio.c num_blocks = len / block_size; block_size 783 drivers/net/wireless/rsi/rsi_91x_sdio.c if (len % block_size) block_size 786 drivers/net/wireless/rsi/rsi_91x_sdio.c address = (num_blocks * block_size | (queueno << 12)); block_size 787 drivers/net/wireless/rsi/rsi_91x_sdio.c length = num_blocks * block_size; block_size 493 drivers/net/wireless/rsi/rsi_91x_usb.c u32 instructions_sz, u16 block_size, block_size 501 drivers/net/wireless/rsi/rsi_91x_usb.c num_blocks = instructions_sz / block_size; block_size 504 drivers/net/wireless/rsi/rsi_91x_usb.c for (cur_indx = 0, i = 0; i < num_blocks; i++, cur_indx += block_size) { block_size 505 drivers/net/wireless/rsi/rsi_91x_usb.c memcpy(temp_buf, ta_firmware + cur_indx, block_size); block_size 508 drivers/net/wireless/rsi/rsi_91x_usb.c block_size); block_size 513 drivers/net/wireless/rsi/rsi_91x_usb.c base_address += block_size; block_size 516 drivers/net/wireless/rsi/rsi_91x_usb.c if (instructions_sz % block_size) { block_size 517 drivers/net/wireless/rsi/rsi_91x_usb.c memset(temp_buf, 0, block_size); block_size 519 drivers/net/wireless/rsi/rsi_91x_usb.c instructions_sz % block_size); block_size 523 drivers/net/wireless/rsi/rsi_91x_usb.c instructions_sz % block_size); block_size 640 drivers/net/wireless/rsi/rsi_91x_usb.c adapter->block_size = rsi_dev->tx_blk_size; block_size 358 drivers/net/wireless/rsi/rsi_main.h u16 block_size; block_size 397 drivers/net/wireless/rsi/rsi_main.h u32 instructions_size, u16 block_size, block_size 182 drivers/net/wireless/st/cw1200/fwio.c size_t block_size; block_size 208 drivers/net/wireless/st/cw1200/fwio.c tx_size = block_size = min_t(size_t, firmware->size - put, block_size 211 drivers/net/wireless/st/cw1200/fwio.c memcpy(buf, &firmware->data[put], block_size); block_size 212 drivers/net/wireless/st/cw1200/fwio.c if (block_size < DOWNLOAD_BLOCK_SIZE) { block_size 213 drivers/net/wireless/st/cw1200/fwio.c memset(&buf[block_size], 0, block_size 214 drivers/net/wireless/st/cw1200/fwio.c DOWNLOAD_BLOCK_SIZE - block_size); block_size 230 drivers/net/wireless/st/cw1200/fwio.c put += block_size; block_size 114 drivers/s390/block/dasd_diag.c iib->block_size = blocksize; block_size 436 drivers/s390/block/dasd_diag.c bsize = (unsigned int) label->block_size; block_size 60 drivers/s390/block/dasd_diag.h u32 block_size; block_size 385 drivers/s390/char/sclp_cmd.c unsigned long long start, size, addr, block_size; block_size 404 drivers/s390/char/sclp_cmd.c block_size = memory_block_size_bytes(); block_size 405 drivers/s390/char/sclp_cmd.c align_to_block_size(&start, &size, block_size); block_size 408 drivers/s390/char/sclp_cmd.c for (addr = start; addr < start + size; addr += block_size) block_size 409 drivers/s390/char/sclp_cmd.c add_memory(numa_pfn_to_nid(PFN_DOWN(addr)), addr, block_size); block_size 176 drivers/s390/char/tape.h int block_size; /* of size block_size. */ block_size 98 drivers/s390/char/tape_char.c tapechar_check_idalbuffer(struct tape_device *device, size_t block_size) block_size 103 drivers/s390/char/tape_char.c device->char_data.idal_buf->size == block_size) block_size 106 drivers/s390/char/tape_char.c if (block_size > MAX_BLOCKSIZE) { block_size 108 drivers/s390/char/tape_char.c block_size, MAX_BLOCKSIZE); block_size 113 drivers/s390/char/tape_char.c new = idal_buffer_alloc(block_size, 0); block_size 133 drivers/s390/char/tape_char.c size_t block_size; block_size 149 drivers/s390/char/tape_char.c if (device->char_data.block_size != 0) { block_size 150 drivers/s390/char/tape_char.c if (count < device->char_data.block_size) { block_size 155 drivers/s390/char/tape_char.c block_size = device->char_data.block_size; block_size 157 drivers/s390/char/tape_char.c block_size = count; block_size 160 drivers/s390/char/tape_char.c rc = tapechar_check_idalbuffer(device, block_size); block_size 164 drivers/s390/char/tape_char.c DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size); block_size 166 drivers/s390/char/tape_char.c request = device->discipline->read_block(device, block_size); block_size 172 drivers/s390/char/tape_char.c rc = block_size - request->rescnt; block_size 191 drivers/s390/char/tape_char.c size_t block_size; block_size 199 drivers/s390/char/tape_char.c if (device->char_data.block_size != 0) { block_size 200 drivers/s390/char/tape_char.c if (count < device->char_data.block_size) { block_size 205 drivers/s390/char/tape_char.c block_size = device->char_data.block_size; block_size 206 drivers/s390/char/tape_char.c nblocks = count / block_size; block_size 208 drivers/s390/char/tape_char.c block_size = count; block_size 212 drivers/s390/char/tape_char.c rc = tapechar_check_idalbuffer(device, block_size); block_size 216 drivers/s390/char/tape_char.c DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size); block_size 219 drivers/s390/char/tape_char.c request = device->discipline->write_block(device, block_size); block_size 227 drivers/s390/char/tape_char.c data, block_size)) { block_size 235 drivers/s390/char/tape_char.c block_size - request->rescnt); block_size 236 drivers/s390/char/tape_char.c written += block_size - request->rescnt; block_size 239 drivers/s390/char/tape_char.c data += block_size; block_size 407 drivers/s390/char/tape_char.c ((device->char_data.block_size << MT_ST_BLKSIZE_SHIFT) block_size 164 drivers/s390/char/tape_core.c return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size); block_size 61 drivers/s390/char/tape_proc.c if (device->char_data.block_size == 0) block_size 64 drivers/s390/char/tape_proc.c seq_printf(m, "%i\t", device->char_data.block_size); block_size 223 drivers/s390/char/tape_std.c device->char_data.block_size = 0; block_size 244 drivers/s390/char/tape_std.c device->char_data.block_size = count; block_size 246 drivers/s390/char/tape_std.c DBF_LH(6, "new blocksize is %d\n", device->char_data.block_size); block_size 258 drivers/s390/char/tape_std.c device->char_data.block_size = 0; block_size 646 drivers/scsi/aacraid/aachba.c dresp->mnt[0].fileinfo.bdevinfo.block_size = 0x200; block_size 647 drivers/scsi/aacraid/aachba.c fsa_dev_ptr->block_size = 0x200; block_size 649 drivers/scsi/aacraid/aachba.c fsa_dev_ptr->block_size = block_size 650 drivers/scsi/aacraid/aachba.c le32_to_cpu(dresp->mnt[0].fileinfo.bdevinfo.block_size); block_size 1227 drivers/scsi/aacraid/aachba.c dev->fsa_dev[scmd_id(cmd)].block_size); block_size 1243 drivers/scsi/aacraid/aachba.c dev->fsa_dev[scmd_id(cmd)].block_size); block_size 1317 drivers/scsi/aacraid/aachba.c dev->fsa_dev[scmd_id(cmd)].block_size); block_size 1355 drivers/scsi/aacraid/aachba.c dev->fsa_dev[scmd_id(cmd)].block_size); block_size 1374 drivers/scsi/aacraid/aachba.c dev->fsa_dev[scmd_id(cmd)].block_size); block_size 1451 drivers/scsi/aacraid/aachba.c dev->fsa_dev[scmd_id(cmd)].block_size); block_size 3067 drivers/scsi/aacraid/aachba.c cp[8] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff; block_size 3068 drivers/scsi/aacraid/aachba.c cp[9] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff; block_size 3069 drivers/scsi/aacraid/aachba.c cp[10] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff; block_size 3070 drivers/scsi/aacraid/aachba.c cp[11] = (fsa_dev_ptr[cid].block_size) & 0xff; block_size 3106 drivers/scsi/aacraid/aachba.c cp[4] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff; block_size 3107 drivers/scsi/aacraid/aachba.c cp[5] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff; block_size 3108 drivers/scsi/aacraid/aachba.c cp[6] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff; block_size 3109 drivers/scsi/aacraid/aachba.c cp[7] = (fsa_dev_ptr[cid].block_size) & 0xff; block_size 3149 drivers/scsi/aacraid/aachba.c (fsa_dev_ptr[cid].block_size >> 16) & 0xff; block_size 3151 drivers/scsi/aacraid/aachba.c (fsa_dev_ptr[cid].block_size >> 8) & 0xff; block_size 3153 drivers/scsi/aacraid/aachba.c fsa_dev_ptr[cid].block_size & 0xff; block_size 3237 drivers/scsi/aacraid/aachba.c (fsa_dev_ptr[cid].block_size >> 16) & 0xff; block_size 3239 drivers/scsi/aacraid/aachba.c (fsa_dev_ptr[cid].block_size >> 8) & 0xff; block_size 3241 drivers/scsi/aacraid/aachba.c fsa_dev_ptr[cid].block_size & 0xff; block_size 333 drivers/scsi/aacraid/aacraid.h u16 block_size; /* sector size in bytes */ block_size 1287 drivers/scsi/aacraid/aacraid.h u32 block_size; block_size 2149 drivers/scsi/aacraid/aacraid.h __le32 block_size; block_size 1474 drivers/scsi/cxlflash/superpipe.c attach->block_size = gli->blk_len; block_size 1487 drivers/scsi/cxlflash/superpipe.c __func__, ctxid, fd, attach->block_size, rc, attach->last_lba); block_size 180 drivers/scsi/dpti.h u32 block_size; block_size 195 drivers/scsi/esas2r/atvda.h u32 block_size; block_size 292 drivers/scsi/esas2r/atvda.h u32 block_size; block_size 355 drivers/scsi/esas2r/atvda.h u32 block_size; block_size 469 drivers/scsi/esas2r/atvda.h u32 block_size; block_size 637 drivers/scsi/esas2r/esas2r.h u32 block_size; block_size 733 drivers/scsi/esas2r/esas2r.h u32 block_size; block_size 656 drivers/scsi/esas2r/esas2r_disc.c dc->block_size = le32_to_cpu(grpinfo->block_size); block_size 1109 drivers/scsi/esas2r/esas2r_disc.c dc->block_size = luevt->id.tgtlun_raid.dwblock_size; block_size 1112 drivers/scsi/esas2r/esas2r_disc.c dc->block_size = 0; block_size 596 drivers/scsi/esas2r/esas2r_io.c sgc->length = startlba * t->block_size; block_size 1348 drivers/scsi/esas2r/esas2r_main.c d->block_size = le32_to_cpu(d->block_size); block_size 1376 drivers/scsi/esas2r/esas2r_main.c g->block_size = le32_to_cpu(g->block_size); block_size 1396 drivers/scsi/esas2r/esas2r_main.c p->block_size = le32_to_cpu(p->block_size); block_size 146 drivers/scsi/esas2r/esas2r_targdb.c || dc->block_size == 0) { block_size 156 drivers/scsi/esas2r/esas2r_targdb.c t->block_size = dc->block_size; block_size 158 drivers/scsi/esas2r/esas2r_targdb.c t->inter_block = dc->interleave / dc->block_size; block_size 205 drivers/scsi/esas2r/esas2r_targdb.c t->block_size = 0; block_size 1267 drivers/scsi/gdth.c ha->cpar.write_back,ha->cpar.block_size)); block_size 515 drivers/scsi/gdth.h u16 block_size; /* cache block size */ block_size 710 drivers/scsi/hpsa_cmd.h __le16 block_size; /* sector size in bytes */ block_size 44 drivers/scsi/ps3rom.c u32 block_size; block_size 98 drivers/scsi/ps3rom.c atapi_cmnd.block_size = 1; /* transfer size is block_size * blocks */ block_size 1449 drivers/scsi/qla2xxx/qla_fw.h uint32_t block_size; block_size 987 drivers/scsi/qla2xxx/qla_sup.c ha->fdt_block_size = le32_to_cpu(fdt->block_size); block_size 391 drivers/scsi/qla2xxx/tcm_qla2xxx.c cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size; block_size 653 drivers/scsi/qla2xxx/tcm_qla2xxx.c cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size; block_size 312 drivers/scsi/qla4xxx/ql4_fw.h uint32_t block_size; block_size 3874 drivers/scsi/qla4xxx/ql4_nx.c hw->fdt_block_size = le32_to_cpu(fdt->block_size); block_size 1256 drivers/scsi/smartpqi/smartpqi.h __le16 block_size; /* sector size in bytes */ block_size 693 drivers/scsi/st.c if (STp->block_size == 0) block_size 696 drivers/scsi/st.c STps->drv_block += STbuffer->writing / STp->block_size; block_size 784 drivers/scsi/st.c blks = transfer / STp->block_size; block_size 848 drivers/scsi/st.c if (STp->block_size == 0) block_size 852 drivers/scsi/st.c (STp->buffer)->read_pointer) / STp->block_size - block_size 853 drivers/scsi/st.c ((STp->buffer)->read_pointer + STp->block_size - 1) / block_size 854 drivers/scsi/st.c STp->block_size; block_size 897 drivers/scsi/st.c STm->default_blksize != STp->block_size) { block_size 901 drivers/scsi/st.c arg |= STp->block_size; block_size 1097 drivers/scsi/st.c STp->block_size = 0; block_size 1148 drivers/scsi/st.c STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ block_size 1162 drivers/scsi/st.c STp->block_size = (STp->buffer)->b_data[9] * 65536 + block_size 1184 drivers/scsi/st.c if (STp->block_size > 0) block_size 1186 drivers/scsi/st.c (STp->buffer)->buffer_size / STp->block_size; block_size 1192 drivers/scsi/st.c STp->block_size, (STp->buffer)->buffer_size, block_size 1528 drivers/scsi/st.c if (STp->block_size == 0 && STp->max_block > 0 && block_size 1576 drivers/scsi/st.c if (STp->block_size) block_size 1577 drivers/scsi/st.c bufsize = STp->block_size > st_fixed_buffer_size ? block_size 1578 drivers/scsi/st.c STp->block_size : st_fixed_buffer_size; block_size 1595 drivers/scsi/st.c if (STp->block_size) block_size 1596 drivers/scsi/st.c STbp->buffer_blocks = bufsize / STp->block_size; block_size 1643 drivers/scsi/st.c if (STp->block_size != 0 && (count % STp->block_size) != 0) { block_size 1702 drivers/scsi/st.c if (STp->block_size != 0 && block_size 1718 drivers/scsi/st.c cmd[1] = (STp->block_size != 0); block_size 1729 drivers/scsi/st.c if (STp->block_size == 0) block_size 1732 drivers/scsi/st.c do_count = STbp->buffer_blocks * STp->block_size - block_size 1747 drivers/scsi/st.c async_write = STp->block_size == 0 && !STbp->do_dio && block_size 1750 drivers/scsi/st.c if (STp->block_size != 0 && STm->do_buffer_writes && block_size 1760 drivers/scsi/st.c if (STp->block_size == 0) block_size 1767 drivers/scsi/st.c blks /= STp->block_size; block_size 1768 drivers/scsi/st.c transfer = blks * STp->block_size; block_size 1798 drivers/scsi/st.c else if (STp->block_size == 0 && block_size 1803 drivers/scsi/st.c if (STp->block_size != 0) block_size 1804 drivers/scsi/st.c undone *= STp->block_size; block_size 1810 drivers/scsi/st.c if (STp->block_size) block_size 1811 drivers/scsi/st.c blks = (transfer - undone) / STp->block_size; block_size 1817 drivers/scsi/st.c if (STp->block_size == 0 || block_size 1832 drivers/scsi/st.c STp->block_size; block_size 1862 drivers/scsi/st.c if (STp->block_size == 0) block_size 1919 drivers/scsi/st.c if (STp->block_size == 0) block_size 1924 drivers/scsi/st.c bytes = blks * STp->block_size; block_size 1929 drivers/scsi/st.c blks = bytes / STp->block_size; block_size 1930 drivers/scsi/st.c bytes = blks * STp->block_size; block_size 1936 drivers/scsi/st.c cmd[1] = (STp->block_size != 0); block_size 1978 drivers/scsi/st.c if (STp->block_size == 0) block_size 1985 drivers/scsi/st.c if (STp->block_size == 0 && block_size 1997 drivers/scsi/st.c } else if (STp->block_size == 0) { block_size 2013 drivers/scsi/st.c STp->block_size; block_size 2029 drivers/scsi/st.c if (STp->block_size == 0) block_size 2033 drivers/scsi/st.c bytes - transfer * STp->block_size; block_size 2042 drivers/scsi/st.c if (STp->block_size == 0) block_size 2046 drivers/scsi/st.c bytes - transfer * STp->block_size; block_size 2084 drivers/scsi/st.c if (STp->block_size == 0) block_size 2087 drivers/scsi/st.c STps->drv_block += STbp->buffer_bytes / STp->block_size; block_size 2115 drivers/scsi/st.c if (STp->block_size != 0 && (count % STp->block_size) != 0) { block_size 2202 drivers/scsi/st.c if (STp->block_size == 0) block_size 2934 drivers/scsi/st.c ltmp = STp->block_size; block_size 2980 drivers/scsi/st.c STp->block_size = arg & MT_ST_BLKSIZE_MASK; block_size 2981 drivers/scsi/st.c if (STp->block_size != 0) { block_size 2983 drivers/scsi/st.c (STp->buffer)->buffer_size / STp->block_size; block_size 3755 drivers/scsi/st.c ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | block_size 3759 drivers/scsi/st.c if (STp->block_size != 0) { block_size 3762 drivers/scsi/st.c (STp->buffer)->buffer_bytes / STp->block_size; block_size 3766 drivers/scsi/st.c STp->block_size - 1) / STp->block_size; block_size 3797 drivers/scsi/st.c (STm->do_buffer_writes && STp->block_size != 0) || block_size 176 drivers/scsi/st.h int block_size; block_size 379 drivers/staging/comedi/comedi_buf.c int block_size = num_bytes - count; block_size 383 drivers/staging/comedi/comedi_buf.c if (block_size > buf_end) block_size 384 drivers/staging/comedi/comedi_buf.c block_size = buf_end; block_size 388 drivers/staging/comedi/comedi_buf.c block_size, async->munge_chan); block_size 396 drivers/staging/comedi/comedi_buf.c async->munge_chan += block_size / num_sample_bytes; block_size 398 drivers/staging/comedi/comedi_buf.c async->munge_count += block_size; block_size 399 drivers/staging/comedi/comedi_buf.c async->munge_ptr += block_size; block_size 401 drivers/staging/comedi/comedi_buf.c count += block_size; block_size 565 drivers/staging/comedi/comedi_buf.c unsigned int block_size; block_size 568 drivers/staging/comedi/comedi_buf.c block_size = async->prealloc_bufsz - write_ptr; block_size 570 drivers/staging/comedi/comedi_buf.c block_size = num_bytes; block_size 572 drivers/staging/comedi/comedi_buf.c memcpy(async->prealloc_buf + write_ptr, data, block_size); block_size 574 drivers/staging/comedi/comedi_buf.c data += block_size; block_size 575 drivers/staging/comedi/comedi_buf.c num_bytes -= block_size; block_size 589 drivers/staging/comedi/comedi_buf.c unsigned int block_size; block_size 594 drivers/staging/comedi/comedi_buf.c block_size = async->prealloc_bufsz - read_ptr; block_size 596 drivers/staging/comedi/comedi_buf.c block_size = nbytes; block_size 598 drivers/staging/comedi/comedi_buf.c memcpy(dest, src, block_size); block_size 599 drivers/staging/comedi/comedi_buf.c nbytes -= block_size; block_size 600 drivers/staging/comedi/comedi_buf.c dest += block_size; block_size 1907 drivers/staging/comedi/drivers/cb_pcidas64.c unsigned int block_size, requested_block_size; block_size 1921 drivers/staging/comedi/drivers/cb_pcidas64.c block_size = ai_fifo_size(dev) / fifo->num_segments * bytes_in_sample; block_size 1923 drivers/staging/comedi/drivers/cb_pcidas64.c data[1] = block_size; block_size 138 drivers/staging/comedi/drivers/gsc_hpdi.c unsigned int block_size; block_size 157 drivers/staging/comedi/drivers/gsc_hpdi.c for (desc = 0; (next < start || next >= start + devpriv->block_size) && block_size 160 drivers/staging/comedi/drivers/gsc_hpdi.c size = devpriv->block_size / sizeof(u32); block_size 449 drivers/staging/comedi/drivers/gsc_hpdi.c devpriv->block_size = len; block_size 1883 drivers/staging/rts5208/ms.c u16 i, reg_addr, block_size; block_size 2015 drivers/staging/rts5208/ms.c block_size = ((u16)ptr[6] << 8) | ptr[7]; block_size 2016 drivers/staging/rts5208/ms.c if (block_size == 0x0010) { block_size 2020 drivers/staging/rts5208/ms.c } else if (block_size == 0x0008) { block_size 28 drivers/staging/wilc1000/wilc_sdio.c u32 block_size; block_size 51 drivers/staging/wilc1000/wilc_sdio.c u32 block_size; block_size 100 drivers/staging/wilc1000/wilc_sdio.c func->cur_blksize = cmd->block_size; block_size 102 drivers/staging/wilc1000/wilc_sdio.c size = cmd->count * cmd->block_size; block_size 300 drivers/staging/wilc1000/wilc_sdio.c static int wilc_sdio_set_func0_block_size(struct wilc *wilc, u32 block_size) block_size 310 drivers/staging/wilc1000/wilc_sdio.c cmd.data = (u8)block_size; block_size 318 drivers/staging/wilc1000/wilc_sdio.c cmd.data = (u8)(block_size >> 8); block_size 336 drivers/staging/wilc1000/wilc_sdio.c static int wilc_sdio_set_func1_block_size(struct wilc *wilc, u32 block_size) block_size 346 drivers/staging/wilc1000/wilc_sdio.c cmd.data = (u8)block_size; block_size 353 drivers/staging/wilc1000/wilc_sdio.c cmd.data = (u8)(block_size >> 8); block_size 408 drivers/staging/wilc1000/wilc_sdio.c cmd.block_size = sdio_priv->block_size; block_size 428 drivers/staging/wilc1000/wilc_sdio.c u32 block_size = sdio_priv->block_size; block_size 463 drivers/staging/wilc1000/wilc_sdio.c nblk = size / block_size; block_size 464 drivers/staging/wilc1000/wilc_sdio.c nleft = size % block_size; block_size 471 drivers/staging/wilc1000/wilc_sdio.c cmd.block_size = block_size; block_size 483 drivers/staging/wilc1000/wilc_sdio.c addr += nblk * block_size; block_size 484 drivers/staging/wilc1000/wilc_sdio.c buf += nblk * block_size; block_size 493 drivers/staging/wilc1000/wilc_sdio.c cmd.block_size = block_size; block_size 548 drivers/staging/wilc1000/wilc_sdio.c cmd.block_size = sdio_priv->block_size; block_size 570 drivers/staging/wilc1000/wilc_sdio.c u32 block_size = sdio_priv->block_size; block_size 605 drivers/staging/wilc1000/wilc_sdio.c nblk = size / block_size; block_size 606 drivers/staging/wilc1000/wilc_sdio.c nleft = size % block_size; block_size 613 drivers/staging/wilc1000/wilc_sdio.c cmd.block_size = block_size; block_size 625 drivers/staging/wilc1000/wilc_sdio.c addr += nblk * block_size; block_size 626 drivers/staging/wilc1000/wilc_sdio.c buf += nblk * block_size; block_size 635 drivers/staging/wilc1000/wilc_sdio.c cmd.block_size = block_size; block_size 699 drivers/staging/wilc1000/wilc_sdio.c sdio_priv->block_size = WILC_SDIO_BLOCK_SIZE; block_size 475 drivers/target/target_core_alua.c sectors = cmd->data_length / dev->dev_attrib.block_size; block_size 538 drivers/target/target_core_configfs.c DEF_CONFIGFS_ATTRIB_SHOW(block_size); block_size 1088 drivers/target/target_core_configfs.c da->block_size = val; block_size 1136 drivers/target/target_core_configfs.c CONFIGFS_ATTR(, block_size); block_size 531 drivers/target/target_core_device.c static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size) block_size 539 drivers/target/target_core_device.c alignment = max(1ul, PAGE_SIZE / block_size); block_size 818 drivers/target/target_core_device.c int block_size = queue_logical_block_size(q); block_size 824 drivers/target/target_core_device.c q->limits.max_discard_sectors >> (ilog2(block_size) - 9); block_size 829 drivers/target/target_core_device.c attrib->unmap_granularity = q->limits.discard_granularity / block_size; block_size 831 drivers/target/target_core_device.c block_size; block_size 843 drivers/target/target_core_device.c switch (dev->dev_attrib.block_size) { block_size 947 drivers/target/target_core_device.c dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size; block_size 297 drivers/target/target_core_file.c aio_cmd->iocb.ki_pos = cmd->t_task_lba * dev->dev_attrib.block_size; block_size 319 drivers/target/target_core_file.c u32 block_size, struct scatterlist *sgl, block_size 326 drivers/target/target_core_file.c loff_t pos = (cmd->t_task_lba * block_size); block_size 414 drivers/target/target_core_file.c start = cmd->t_task_lba * dev->dev_attrib.block_size; block_size 441 drivers/target/target_core_file.c loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size; block_size 459 drivers/target/target_core_file.c cmd->t_data_sg[0].length != cmd->se_dev->dev_attrib.block_size) { block_size 464 drivers/target/target_core_file.c cmd->se_dev->dev_attrib.block_size); block_size 477 drivers/target/target_core_file.c len += se_dev->dev_attrib.block_size; block_size 577 drivers/target/target_core_file.c loff_t pos = lba * se_dev->dev_attrib.block_size; block_size 578 drivers/target/target_core_file.c unsigned int len = nolb * se_dev->dev_attrib.block_size; block_size 617 drivers/target/target_core_file.c ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size, block_size 623 drivers/target/target_core_file.c ilog2(dev->dev_attrib.block_size); block_size 634 drivers/target/target_core_file.c ilog2(dev->dev_attrib.block_size); block_size 642 drivers/target/target_core_file.c ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size, block_size 651 drivers/target/target_core_file.c dev->dev_attrib.block_size; block_size 831 drivers/target/target_core_file.c return div_u64(dev_size - dev->dev_attrib.block_size, block_size 832 drivers/target/target_core_file.c dev->dev_attrib.block_size); block_size 875 drivers/target/target_core_file.c int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size; block_size 198 drivers/target/target_core_iblock.c u32 block_size = bdev_logical_block_size(bd); block_size 200 drivers/target/target_core_iblock.c if (block_size == dev->dev_attrib.block_size) block_size 203 drivers/target/target_core_iblock.c switch (block_size) { block_size 205 drivers/target/target_core_iblock.c switch (dev->dev_attrib.block_size) { block_size 219 drivers/target/target_core_iblock.c switch (dev->dev_attrib.block_size) { block_size 234 drivers/target/target_core_iblock.c switch (dev->dev_attrib.block_size) { block_size 249 drivers/target/target_core_iblock.c switch (dev->dev_attrib.block_size) { block_size 464 drivers/target/target_core_iblock.c sg->length != cmd->se_dev->dev_attrib.block_size) { block_size 467 drivers/target/target_core_iblock.c cmd->se_dev->dev_attrib.block_size); block_size 233 drivers/target/target_core_rd.c static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size) block_size 249 drivers/target/target_core_rd.c total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1; block_size 385 drivers/target/target_core_rd.c u32 sectors = cmd->data_length / se_dev->dev_attrib.block_size; block_size 437 drivers/target/target_core_rd.c tmp = cmd->t_task_lba * se_dev->dev_attrib.block_size; block_size 604 drivers/target/target_core_rd.c dev->dev_attrib.block_size) - 1; block_size 617 drivers/target/target_core_rd.c dev->dev_attrib.block_size); block_size 62 drivers/target/target_core_sbc.c put_unaligned_be32(dev->dev_attrib.block_size, &buf[4]); block_size 87 drivers/target/target_core_sbc.c put_unaligned_be32(dev->dev_attrib.block_size, &buf[8]); block_size 218 drivers/target/target_core_sbc.c return cmd->se_dev->dev_attrib.block_size * sectors; block_size 447 drivers/target/target_core_sbc.c unsigned int block_size = dev->dev_attrib.block_size; block_size 448 drivers/target/target_core_sbc.c unsigned int compare_len = (nlbas * block_size); block_size 526 drivers/target/target_core_sbc.c len = cmd->t_task_nolb * block_size; block_size 534 drivers/target/target_core_sbc.c if (block_size < PAGE_SIZE) { block_size 535 drivers/target/target_core_sbc.c sg_set_page(&write_sg[i], m.page, block_size, block_size 536 drivers/target/target_core_sbc.c m.piter.sg->offset + block_size); block_size 539 drivers/target/target_core_sbc.c sg_set_page(&write_sg[i], m.page, block_size, block_size 542 drivers/target/target_core_sbc.c len -= block_size; block_size 610 drivers/target/target_core_sbc.c cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size; block_size 757 drivers/target/target_core_sbc.c cmd->data_length = sectors * dev->dev_attrib.block_size; block_size 1230 drivers/target/target_core_sbc.c unsigned int block_size = dev->dev_attrib.block_size; block_size 1253 drivers/target/target_core_sbc.c avail = min(block_size, dsg->length - offset); block_size 1255 drivers/target/target_core_sbc.c if (avail < block_size) { block_size 1263 drivers/target/target_core_sbc.c offset = block_size - avail; block_size 1266 drivers/target/target_core_sbc.c offset += block_size; block_size 1387 drivers/target/target_core_sbc.c unsigned int block_size = dev->dev_attrib.block_size; block_size 1418 drivers/target/target_core_sbc.c dsg_off += block_size; block_size 1422 drivers/target/target_core_sbc.c avail = min(block_size, dsg->length - dsg_off); block_size 1424 drivers/target/target_core_sbc.c if (avail < block_size) { block_size 1432 drivers/target/target_core_sbc.c dsg_off = block_size - avail; block_size 1435 drivers/target/target_core_sbc.c dsg_off += block_size; block_size 509 drivers/target/target_core_spc.c put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]); block_size 521 drivers/target/target_core_spc.c dev->dev_attrib.block_size; block_size 529 drivers/target/target_core_spc.c put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]); block_size 957 drivers/target/target_core_spc.c static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size) block_size 962 drivers/target/target_core_spc.c put_unaligned_be32(block_size, buf); block_size 966 drivers/target/target_core_spc.c static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size) block_size 969 drivers/target/target_core_spc.c return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3; block_size 976 drivers/target/target_core_spc.c put_unaligned_be32(block_size, buf); block_size 1027 drivers/target/target_core_spc.c u32 block_size = dev->dev_attrib.block_size; block_size 1032 drivers/target/target_core_spc.c blocks, block_size); block_size 1036 drivers/target/target_core_spc.c blocks, block_size); block_size 1040 drivers/target/target_core_spc.c block_size); block_size 969 drivers/target/target_core_transport.c dev->dev_attrib.block_size, block_size 1272 drivers/target/target_core_transport.c u32 sectors = (mtl / dev->dev_attrib.block_size); block_size 1314 drivers/target/target_core_transport.c if (dev->dev_attrib.block_size != 512) { block_size 1979 drivers/target/target_core_transport.c sectors = cmd->data_length >> ilog2(cmd->se_dev->dev_attrib.block_size); block_size 2242 drivers/target/target_core_transport.c ilog2(cmd->se_dev->dev_attrib.block_size); block_size 2560 drivers/target/target_core_transport.c cmd->se_dev->dev_attrib.block_size; block_size 2582 drivers/target/target_core_transport.c cmd->se_dev->dev_attrib.block_size; block_size 2234 drivers/target/target_core_user.c return div_u64(udev->dev_size - dev->dev_attrib.block_size, block_size 2235 drivers/target/target_core_user.c dev->dev_attrib.block_size); block_size 610 drivers/target/target_core_xcopy.c u32 length = (src_sectors * src_dev->dev_attrib.block_size); block_size 672 drivers/target/target_core_xcopy.c u32 length = (dst_sectors * dst_dev->dev_attrib.block_size); block_size 805 drivers/target/target_core_xcopy.c copied_nolb, copied_nolb * dst_dev->dev_attrib.block_size); block_size 897 drivers/target/target_core_xcopy.c if (xop->src_dev->dev_attrib.block_size != block_size 898 drivers/target/target_core_xcopy.c xop->dst_dev->dev_attrib.block_size) { block_size 901 drivers/target/target_core_xcopy.c xop->src_dev->dev_attrib.block_size, block_size 902 drivers/target/target_core_xcopy.c xop->dst_dev->dev_attrib.block_size); block_size 164 drivers/tty/serial/8250/8250_lpss.c .block_size = 4095, block_size 2295 drivers/usb/host/xhci.c unsigned int block_size; block_size 2319 drivers/usb/host/xhci.c block_size = xhci_get_block_size(virt_dev->udev); block_size 2346 drivers/usb/host/xhci.c bw_used = DIV_ROUND_UP(bw_table->interval0_esit_payload, block_size) + block_size 2378 drivers/usb/host/xhci.c block_size); block_size 191 drivers/video/fbdev/omap2/omapfb/dss/hdmi.h u8 block_size; block_size 826 drivers/video/fbdev/omap2/omapfb/dss/hdmi4_core.c audio_dma.block_size = 0xC0; block_size 856 drivers/video/fbdev/omap2/omapfb/dss/hdmi5_core.c audio_dma.block_size = 0xC0; block_size 235 drivers/video/fbdev/omap2/omapfb/dss/hdmi_wp.c r = FLD_MOD(r, aud_dma->block_size, 7, 0); block_size 34 fs/befs/befs.h u32 block_size; block_size 145 fs/befs/befs.h return BEFS_SB(sb)->block_size / sizeof(befs_disk_inode_addr); block_size 118 fs/befs/befs_fs_types.h fs32 block_size; block_size 148 fs/befs/datastream.c plen = ((bytes_read + BEFS_SB(sb)->block_size) < len) ? block_size 149 fs/befs/datastream.c BEFS_SB(sb)->block_size : len - bytes_read; block_size 182 fs/befs/datastream.c if (ds->size & (befs_sb->block_size - 1)) block_size 208 fs/befs/datastream.c dbl_bytes / (befs_sb->block_size * BEFS_DBLINDIR_BRUN_LEN); block_size 169 fs/befs/debug.c befs_debug(sb, " block_size %u", fs32_to_cpu(sb, sup->block_size)); block_size 376 fs/befs/linuxvfs.c inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE; block_size 387 fs/befs/linuxvfs.c num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE); block_size 893 fs/befs/linuxvfs.c sb_set_blocksize(sb, (ulong) befs_sb->block_size); block_size 34 fs/befs/super.c befs_sb->block_size = fs32_to_cpu(sb, disk_sb->block_size); block_size 76 fs/befs/super.c if ((befs_sb->block_size != 1024) block_size 77 fs/befs/super.c && (befs_sb->block_size != 2048) block_size 78 fs/befs/super.c && (befs_sb->block_size != 4096) block_size 79 fs/befs/super.c && (befs_sb->block_size != 8192)) { block_size 80 fs/befs/super.c befs_error(sb, "invalid blocksize: %u", befs_sb->block_size); block_size 84 fs/befs/super.c if (befs_sb->block_size > PAGE_SIZE) { block_size 86 fs/befs/super.c "than system pagesize(%lu)", befs_sb->block_size, block_size 96 fs/befs/super.c if ((1 << befs_sb->block_shift) != befs_sb->block_size) { block_size 202 fs/ceph/ioctl.c dl.block_size = ci->i_layout.stripe_unit; block_size 206 fs/ceph/ioctl.c dl.block_offset = do_div(tmp, dl.block_size); block_size 63 fs/ceph/ioctl.h __u64 block_size; /* out: block length */ block_size 589 fs/ecryptfs/keystore.c size_t block_size; block_size 652 fs/ecryptfs/keystore.c s->block_size = crypto_skcipher_blocksize(s->skcipher_tfm); block_size 657 fs/ecryptfs/keystore.c if ((s->block_aligned_filename_size % s->block_size) != 0) { block_size 658 fs/ecryptfs/keystore.c s->num_rand_bytes += (s->block_size block_size 660 fs/ecryptfs/keystore.c % s->block_size)); block_size 861 fs/ecryptfs/keystore.c size_t block_size; block_size 75 fs/hfsplus/btree.c u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size, block_size 78 fs/hfsplus/btree.c u32 mod = max(node_size, block_size); block_size 394 fs/hfsplus/hfsplus_fs.h u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size, u64 sectors, block_size 70 fs/iomap/buffered-io.c unsigned block_size = (1 << block_bits); block_size 88 fs/iomap/buffered-io.c *pos += block_size; block_size 89 fs/iomap/buffered-io.c poff += block_size; block_size 90 fs/iomap/buffered-io.c plen -= block_size; block_size 97 fs/iomap/buffered-io.c plen -= (last - i + 1) * block_size; block_size 113 fs/iomap/buffered-io.c plen -= (last - end) * block_size; block_size 554 fs/iomap/buffered-io.c loff_t block_size = i_blocksize(inode); block_size 555 fs/iomap/buffered-io.c loff_t block_start = pos & ~(block_size - 1); block_size 556 fs/iomap/buffered-io.c loff_t block_end = (pos + len + block_size - 1) & ~(block_size - 1); block_size 49 fs/isofs/compress.c int i, block_size = block_end - block_start; block_size 54 fs/isofs/compress.c int needblocks = (block_size + (block_start & bufmask) + bufmask) block_size 61 fs/isofs/compress.c if (block_size > deflateBound(1UL << zisofs_block_shift)) { block_size 66 fs/isofs/compress.c if (block_size == 0) { block_size 142 fs/isofs/compress.c block_size); block_size 143 fs/isofs/compress.c block_size -= stream.avail_in; block_size 29 fs/nfsd/blocklayout.c u32 block_size = i_blocksize(inode); block_size 35 fs/nfsd/blocklayout.c if (seg->offset & (block_size - 1)) { block_size 107 fs/nfsd/blocklayoutxdr.c u32 block_size) block_size 142 fs/nfsd/blocklayoutxdr.c if (bex.foff & (block_size - 1)) { block_size 148 fs/nfsd/blocklayoutxdr.c if (bex.len & (block_size - 1)) { block_size 154 fs/nfsd/blocklayoutxdr.c if (bex.soff & (block_size - 1)) { block_size 179 fs/nfsd/blocklayoutxdr.c u32 block_size) block_size 207 fs/nfsd/blocklayoutxdr.c if (val & (block_size - 1)) { block_size 214 fs/nfsd/blocklayoutxdr.c if (val & (block_size - 1)) { block_size 58 fs/nfsd/blocklayoutxdr.h u32 block_size); block_size 60 fs/nfsd/blocklayoutxdr.h u32 block_size); block_size 1312 fs/nilfs2/super.c sb_set_blocksize(s, block_size(sd.bdev)); block_size 129 fs/ntfs/aops.c rec_size = ni->itype.index.block_size; block_size 910 fs/ntfs/aops.c unsigned int rec_size = ni->itype.index.block_size; block_size 1289 fs/ntfs/aops.c if (ni->itype.index.block_size == PAGE_SIZE) block_size 1722 fs/ntfs/aops.c end = ofs + ni->itype.index.block_size; block_size 705 fs/ntfs/attrib.c unsigned long block_size; block_size 719 fs/ntfs/attrib.c block_size = sb->s_blocksize; block_size 753 fs/ntfs/attrib.c if (al + block_size >= al_end) block_size 755 fs/ntfs/attrib.c memcpy(al, bh->b_data, block_size); block_size 757 fs/ntfs/attrib.c al += block_size; block_size 1704 fs/ntfs/attrib.c ni->itype.compressed.block_size = 1U << (a->data. block_size 1708 fs/ntfs/attrib.c ffs(ni->itype.compressed.block_size) - block_size 1713 fs/ntfs/attrib.c ni->itype.compressed.block_size = 0; block_size 471 fs/ntfs/compress.c unsigned long flags, block_size = sb->s_blocksize; block_size 476 fs/ntfs/compress.c u32 cb_size = ni->itype.compressed.block_size; block_size 519 fs/ntfs/compress.c bhs_size = cb_size / block_size * sizeof(struct buffer_head *); block_size 707 fs/ntfs/compress.c memcpy(cb_pos, bhs[i]->b_data, block_size); block_size 708 fs/ntfs/compress.c cb_pos += block_size; block_size 344 fs/ntfs/dir.c dir_ni->itype.index.block_size) { block_size 351 fs/ntfs/dir.c dir_ni->itype.index.block_size); block_size 354 fs/ntfs/dir.c index_end = (u8*)ia + dir_ni->itype.index.block_size; block_size 364 fs/ntfs/dir.c if (index_end > (u8*)ia + dir_ni->itype.index.block_size) { block_size 822 fs/ntfs/dir.c dir_ni->itype.index.block_size) { block_size 829 fs/ntfs/dir.c dir_ni->itype.index.block_size); block_size 832 fs/ntfs/dir.c index_end = (u8*)ia + dir_ni->itype.index.block_size; block_size 842 fs/ntfs/dir.c if (index_end > (u8*)ia + dir_ni->itype.index.block_size) { block_size 1297 fs/ntfs/dir.c ~(s64)(ndir->itype.index.block_size - 1))); block_size 1313 fs/ntfs/dir.c ~(s64)(ndir->itype.index.block_size - 1)) >> block_size 1325 fs/ntfs/dir.c ndir->itype.index.block_size)) { block_size 1333 fs/ntfs/dir.c ndir->itype.index.block_size); block_size 1336 fs/ntfs/dir.c index_end = (u8*)ia + ndir->itype.index.block_size; block_size 1345 fs/ntfs/dir.c ia_start = ia_pos & ~(s64)(ndir->itype.index.block_size - 1); block_size 1347 fs/ntfs/dir.c if (unlikely(index_end > (u8*)ia + ndir->itype.index.block_size)) { block_size 301 fs/ntfs/index.c idx_ni->itype.index.block_size) { block_size 308 fs/ntfs/index.c idx_ni->itype.index.block_size); block_size 311 fs/ntfs/index.c index_end = (u8*)ia + idx_ni->itype.index.block_size; block_size 321 fs/ntfs/index.c if (index_end > (u8*)ia + idx_ni->itype.index.block_size) { block_size 384 fs/ntfs/inode.c ni->itype.index.block_size = 0; block_size 830 fs/ntfs/inode.c ni->itype.index.block_size = le32_to_cpu(ir->index_block_size); block_size 831 fs/ntfs/inode.c if (ni->itype.index.block_size & block_size 832 fs/ntfs/inode.c (ni->itype.index.block_size - 1)) { block_size 835 fs/ntfs/inode.c ni->itype.index.block_size); block_size 838 fs/ntfs/inode.c if (ni->itype.index.block_size > PAGE_SIZE) { block_size 842 fs/ntfs/inode.c ni->itype.index.block_size, block_size 847 fs/ntfs/inode.c if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) { block_size 851 fs/ntfs/inode.c ni->itype.index.block_size, block_size 857 fs/ntfs/inode.c ffs(ni->itype.index.block_size) - 1; block_size 859 fs/ntfs/inode.c if (vol->cluster_size <= ni->itype.index.block_size) { block_size 1073 fs/ntfs/inode.c ni->itype.compressed.block_size = 1U << block_size 1080 fs/ntfs/inode.c block_size) - 1; block_size 1086 fs/ntfs/inode.c ni->itype.compressed.block_size = 0; block_size 1355 fs/ntfs/inode.c ni->itype.compressed.block_size = 1U << block_size 1361 fs/ntfs/inode.c block_size) - 1; block_size 1366 fs/ntfs/inode.c ni->itype.compressed.block_size = 0; block_size 1547 fs/ntfs/inode.c ni->itype.index.block_size = le32_to_cpu(ir->index_block_size); block_size 1548 fs/ntfs/inode.c if (!is_power_of_2(ni->itype.index.block_size)) { block_size 1550 fs/ntfs/inode.c "two.", ni->itype.index.block_size); block_size 1553 fs/ntfs/inode.c if (ni->itype.index.block_size > PAGE_SIZE) { block_size 1556 fs/ntfs/inode.c ni->itype.index.block_size, PAGE_SIZE); block_size 1560 fs/ntfs/inode.c if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) { block_size 1563 fs/ntfs/inode.c ni->itype.index.block_size, NTFS_BLOCK_SIZE); block_size 1567 fs/ntfs/inode.c ni->itype.index.block_size_bits = ffs(ni->itype.index.block_size) - 1; block_size 1569 fs/ntfs/inode.c if (vol->cluster_size <= ni->itype.index.block_size) { block_size 1772 fs/ntfs/inode.c ni->itype.index.block_size = vol->mft_record_size; block_size 90 fs/ntfs/inode.h u32 block_size; /* Size of an index block. */ block_size 101 fs/ntfs/inode.h u32 block_size; /* Size of a compression block block_size 721 fs/ntfs/logfile.c unsigned block_size, block_size_bits; block_size 737 fs/ntfs/logfile.c block_size = sb->s_blocksize; block_size 799 fs/ntfs/logfile.c memset(bh->b_data, -1, block_size); block_size 2659 fs/ntfs/mft.c ni->itype.index.block_size = 4096; block_size 2662 fs/ntfs/mft.c if (vol->cluster_size <= ni->itype.index.block_size) { block_size 1056 fs/ntfs/super.c tmp_ni->itype.index.block_size = vol->mft_record_size; block_size 45 fs/orangefs/downcall.h __s64 block_size; block_size 198 fs/orangefs/super.c (long)new_op->downcall.resp.statfs.block_size, block_size 204 fs/orangefs/super.c buf->f_bsize = new_op->downcall.resp.statfs.block_size; block_size 129 fs/pstore/ram_core.c int ecc_block_size = prz->ecc_info.block_size; block_size 172 fs/pstore/ram_core.c int size = prz->ecc_info.block_size; block_size 183 fs/pstore/ram_core.c block += prz->ecc_info.block_size; block_size 199 fs/pstore/ram_core.c prz->ecc_info.block_size = ecc_info->block_size ?: 128; block_size 205 fs/pstore/ram_core.c prz->ecc_info.block_size + block_size 591 fs/pstore/ram_core.c prz->ecc_info.ecc_size, prz->ecc_info.block_size); block_size 19 fs/reiserfs/item_ops.c static int sd_bytes_number(struct item_head *ih, int block_size) block_size 114 fs/reiserfs/item_ops.c static int direct_bytes_number(struct item_head *ih, int block_size) block_size 205 fs/reiserfs/item_ops.c static int indirect_bytes_number(struct item_head *ih, int block_size) block_size 207 fs/reiserfs/item_ops.c return ih_item_len(ih) / UNFM_P_SIZE * block_size; block_size 349 fs/reiserfs/item_ops.c static int direntry_bytes_number(struct item_head *ih, int block_size) block_size 636 fs/reiserfs/item_ops.c static int errcatch_bytes_number(struct item_head *ih, int block_size) block_size 1625 fs/reiserfs/reiserfs.h #define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE) block_size 1974 fs/reiserfs/reiserfs.h #define REISERFS_MAX_NAME(block_size) 255 block_size 2629 fs/reiserfs/reiserfs.h int (*bytes_number) (struct item_head * ih, int block_size); block_size 1544 fs/reiserfs/stree.c int block_size = sb->s_blocksize; block_size 1560 fs/reiserfs/stree.c block_size - (new_file_size & (block_size - 1)); block_size 213 fs/reiserfs/tail_conversion.c unsigned long block_size = sb->s_blocksize; block_size 228 fs/reiserfs/tail_conversion.c tail_len = (n_new_file_size & (block_size - 1)); block_size 294 fs/reiserfs/tail_conversion.c return block_size - round_tail_len; block_size 317 fs/reiserfs/tail_conversion.c return block_size - round_tail_len; block_size 224 fs/squashfs/cache.c int block_size) block_size 244 fs/squashfs/cache.c cache->block_size = block_size; block_size 245 fs/squashfs/cache.c cache->pages = block_size >> PAGE_SHIFT; block_size 454 fs/squashfs/file.c (i_size_read(inode) & (msblk->block_size - 1)) : block_size 455 fs/squashfs/file.c msblk->block_size; block_size 54 fs/squashfs/lz4_wrapper.c int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE); block_size 60 fs/squashfs/lz4_wrapper.c stream->input = vmalloc(block_size); block_size 63 fs/squashfs/lz4_wrapper.c stream->output = vmalloc(block_size); block_size 30 fs/squashfs/lzo_wrapper.c int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE); block_size 35 fs/squashfs/lzo_wrapper.c stream->input = vmalloc(block_size); block_size 38 fs/squashfs/lzo_wrapper.c stream->output = vmalloc(block_size); block_size 243 fs/squashfs/squashfs_fs.h __le32 block_size; block_size 22 fs/squashfs/squashfs_fs_sb.h int block_size; block_size 61 fs/squashfs/squashfs_fs_sb.h unsigned int block_size; block_size 137 fs/squashfs/super.c msblk->block_size = le32_to_cpu(sblk->block_size); block_size 138 fs/squashfs/super.c if (msblk->block_size > SQUASHFS_FILE_MAX_SIZE) block_size 145 fs/squashfs/super.c if (PAGE_SIZE > msblk->block_size) { block_size 147 fs/squashfs/super.c "currently not supported!", msblk->block_size); block_size 157 fs/squashfs/super.c if (msblk->block_size != (1 << msblk->block_log)) block_size 177 fs/squashfs/super.c TRACE("Block size %d\n", msblk->block_size); block_size 203 fs/squashfs/super.c squashfs_max_decompressors(), msblk->block_size); block_size 273 fs/squashfs/super.c SQUASHFS_CACHED_FRAGMENTS, msblk->block_size); block_size 377 fs/squashfs/super.c buf->f_bsize = msblk->block_size; block_size 69 fs/squashfs/xz_wrapper.c opts->dict_size = max_t(int, msblk->block_size, block_size 36 fs/squashfs/zstd_wrapper.c msblk->block_size, SQUASHFS_METADATA_SIZE); block_size 1341 fs/super.c sb_set_blocksize(s, block_size(bdev)); block_size 1416 fs/super.c sb_set_blocksize(s, block_size(bdev)); block_size 787 fs/ufs/super.c unsigned block_size, super_block_size; block_size 853 fs/ufs/super.c uspi->s_fsize = block_size = 512; block_size 863 fs/ufs/super.c uspi->s_fsize = block_size = 512; block_size 876 fs/ufs/super.c uspi->s_fsize = block_size = 1024; block_size 887 fs/ufs/super.c uspi->s_fsize = block_size = 1024; block_size 899 fs/ufs/super.c uspi->s_fsize = block_size = 1024; block_size 910 fs/ufs/super.c uspi->s_fsize = block_size = 1024; block_size 925 fs/ufs/super.c uspi->s_fsize = block_size = 1024; block_size 941 fs/ufs/super.c uspi->s_fsize = block_size = 2048; block_size 957 fs/ufs/super.c uspi->s_fsize = block_size = 1024; block_size 973 fs/ufs/super.c uspi->s_fsize = block_size = 1024; block_size 992 fs/ufs/super.c if (!sb_set_blocksize(sb, block_size)) { block_size 1001 fs/ufs/super.c ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size); block_size 1102 fs/ufs/super.c if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) { block_size 1105 fs/ufs/super.c block_size = uspi->s_fsize; block_size 1107 fs/ufs/super.c UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size); block_size 28 fs/verity/enable.c if (WARN_ON(params->block_size != PAGE_SIZE)) /* checked earlier too */ block_size 79 fs/verity/enable.c if (pending_size + params->digest_size > params->block_size || block_size 83 fs/verity/enable.c params->block_size - pending_size); block_size 129 fs/verity/enable.c pending_hashes = kmalloc(params->block_size, GFP_KERNEL); block_size 139 fs/verity/enable.c blocks = (inode->i_size + params->block_size - 1) >> block_size 174 fs/verity/enable.c desc->log_blocksize = ilog2(arg->block_size); block_size 315 fs/verity/enable.c if (arg.block_size != PAGE_SIZE) block_size 39 fs/verity/fsverity_private.h unsigned int block_size; /* block size in bytes, e.g. 64 for SHA-256 */ block_size 47 fs/verity/fsverity_private.h unsigned int block_size; /* size of data and tree blocks */ block_size 18 fs/verity/hash_algs.c .block_size = SHA256_BLOCK_SIZE, block_size 23 fs/verity/hash_algs.c .block_size = SHA512_BLOCK_SIZE, block_size 78 fs/verity/hash_algs.c if (WARN_ON(alg->block_size != crypto_ahash_blocksize(tfm))) block_size 135 fs/verity/hash_algs.c padded_salt_size = round_up(salt_size, alg->block_size); block_size 192 fs/verity/hash_algs.c if (WARN_ON(params->block_size != PAGE_SIZE)) block_size 278 fs/verity/hash_algs.c BUG_ON(!is_power_of_2(alg->block_size)); block_size 64 fs/verity/open.c params->block_size = 1 << log_blocksize; block_size 70 fs/verity/open.c if (params->block_size < 2 * params->digest_size) { block_size 73 fs/verity/open.c params->block_size, hash_alg->name); block_size 81 fs/verity/open.c hash_alg->name, params->block_size, params->hashes_per_block, block_size 92 fs/verity/open.c blocks = (inode->i_size + params->block_size - 1) >> log_blocksize; block_size 350 fs/xfs/xfs_buf.h #define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev) block_size 36 include/linux/c2port.h unsigned short block_size; /* flash block size in bytes */ block_size 24 include/linux/dm-bufio.h dm_bufio_client_create(struct block_device *bdev, unsigned block_size, block_size 86 include/linux/iio/buffer-dma.h size_t block_size; block_size 55 include/linux/platform_data/dma-dw.h unsigned int block_size; block_size 35 include/linux/pstore_ram.h int block_size; block_size 687 include/target/target_core_base.h u32 block_size; block_size 182 include/uapi/linux/bcache.h __u16 block_size; /* sectors */ block_size 798 include/uapi/linux/cdrom.h __u32 block_size; block_size 22 include/uapi/linux/fsverity.h __u32 block_size; block_size 79 include/uapi/scsi/cxlflash_ioctl.h __u64 block_size; /* Returned block size, in bytes */ block_size 2886 mm/swapfile.c p->old_block_size = block_size(p->bdev); block_size 202 sound/atmel/ac97c.c int block_size = frames_to_bytes(runtime, runtime->period_size); block_size 273 sound/atmel/ac97c.c writel(block_size / 2, chip->regs + ATMEL_PDC_TCR); block_size 274 sound/atmel/ac97c.c writel(runtime->dma_addr + block_size, chip->regs + ATMEL_PDC_TNPR); block_size 275 sound/atmel/ac97c.c writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR); block_size 284 sound/atmel/ac97c.c int block_size = frames_to_bytes(runtime, runtime->period_size); block_size 355 sound/atmel/ac97c.c writel(block_size / 2, chip->regs + ATMEL_PDC_RCR); block_size 356 sound/atmel/ac97c.c writel(runtime->dma_addr + block_size, chip->regs + ATMEL_PDC_RNPR); block_size 357 sound/atmel/ac97c.c writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR); block_size 492 sound/atmel/ac97c.c int offset, next_period, block_size; block_size 502 sound/atmel/ac97c.c block_size = frames_to_bytes(runtime, runtime->period_size); block_size 511 sound/atmel/ac97c.c offset = block_size * next_period; block_size 514 sound/atmel/ac97c.c writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR); block_size 520 sound/atmel/ac97c.c block_size = frames_to_bytes(runtime, runtime->period_size); block_size 529 sound/atmel/ac97c.c offset = block_size * next_period; block_size 532 sound/atmel/ac97c.c writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR); block_size 42 sound/isa/gus/gus_pcm.c unsigned int block_size; block_size 123 sound/isa/gus/gus_pcm.c curr = begin + (pcmp->bpos * pcmp->block_size) / runtime->channels; block_size 124 sound/isa/gus/gus_pcm.c end = curr + (pcmp->block_size / runtime->channels); block_size 214 sound/isa/gus/gus_pcm.c end = pcmp->memory + (((pcmp->bpos + 1) * pcmp->block_size) / runtime->channels); block_size 245 sound/isa/gus/gus_pcm.c end = pcmp->bpos * pcmp->block_size; block_size 247 sound/isa/gus/gus_pcm.c snd_gf1_pcm_block_change(pcmp->substream, end, pcmp->memory + (end / 2), pcmp->block_size / 2); block_size 248 sound/isa/gus/gus_pcm.c snd_gf1_pcm_block_change(pcmp->substream, end + (pcmp->block_size / 2), pcmp->memory + (pcmp->dma_size / 2) + (end / 2), pcmp->block_size / 2); block_size 250 sound/isa/gus/gus_pcm.c snd_gf1_pcm_block_change(pcmp->substream, end, pcmp->memory + end, pcmp->block_size); block_size 497 sound/isa/gus/gus_pcm.c pcmp->block_size = snd_pcm_lib_period_bytes(substream); block_size 498 sound/isa/gus/gus_pcm.c pcmp->blocks = pcmp->dma_size / pcmp->block_size; block_size 223 sound/oss/dmasound/dmasound.h int block_size; /* internal block size in bytes */ block_size 1178 sound/oss/dmasound/dmasound_atari.c : write_sq.block_size); block_size 1218 sound/oss/dmasound/dmasound_atari.c write_sq.rear_size < write_sq.block_size && block_size 1233 sound/oss/dmasound/dmasound_atari.c write_sq.rear_size < write_sq.block_size && block_size 1248 sound/oss/dmasound/dmasound_atari.c write_sq.rear_size < write_sq.block_size && block_size 486 sound/oss/dmasound/dmasound_core.c sq->block_size = sq->bufSize; block_size 496 sound/oss/dmasound/dmasound_core.c sq->block_size = sq->user_frag_size ; block_size 497 sound/oss/dmasound/dmasound_core.c sq->block_size *= block_size 499 sound/oss/dmasound/dmasound_core.c sq->block_size /= block_size 502 sound/oss/dmasound/dmasound_core.c sq->block_size *= dmasound.hard.speed ; block_size 503 sound/oss/dmasound/dmasound_core.c sq->block_size /= dmasound.soft.speed ; block_size 507 sound/oss/dmasound/dmasound_core.c sq->block_size += (hard_frame - 1) ; block_size 508 sound/oss/dmasound/dmasound_core.c sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */ block_size 510 sound/oss/dmasound/dmasound_core.c if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) { block_size 514 sound/oss/dmasound/dmasound_core.c sq->block_size = sq->bufSize ; block_size 609 sound/oss/dmasound/dmasound_core.c (bLeft = write_sq.block_size-write_sq.rear_size) > 0) { block_size 653 sound/oss/dmasound/dmasound_core.c bLeft = write_sq.block_size; block_size 686 sound/oss/dmasound/dmasound_core.c if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0) block_size 1330 sound/oss/dmasound/dmasound_core.c "write", write_sq.max_count, write_sq.block_size, block_size 472 sound/oss/dmasound/dmasound_paula.c : write_sq.block_size)>>1; block_size 543 sound/oss/dmasound/dmasound_paula.c write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { block_size 648 sound/oss/dmasound/dmasound_paula.c write_sq_block_size_half = write_sq.block_size>>1; block_size 412 sound/oss/dmasound/dmasound_q40.c size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size); block_size 448 sound/oss/dmasound/dmasound_q40.c if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { block_size 2508 sound/soc/intel/skylake/skl-topology.c struct skl_module_cfg *mconfig, int block_size) block_size 2516 sound/soc/intel/skylake/skl-topology.c if (block_size <= 0) block_size 2519 sound/soc/intel/skylake/skl-topology.c while (tuple_size < block_size) { block_size 2766 sound/soc/intel/skylake/skl-topology.c int num_blocks, block_size = 0, block_type, off = 0; block_size 2804 sound/soc/intel/skylake/skl-topology.c block_size = ret; block_size 2814 sound/soc/intel/skylake/skl-topology.c skl, mconfig, block_size); block_size 3343 sound/soc/intel/skylake/skl-topology.c int block_size) block_size 3351 sound/soc/intel/skylake/skl-topology.c if (block_size <= 0) block_size 3354 sound/soc/intel/skylake/skl-topology.c while (tuple_size < block_size) { block_size 3415 sound/soc/intel/skylake/skl-topology.c int num_blocks, block_size = 0, block_type, off = 0; block_size 3445 sound/soc/intel/skylake/skl-topology.c block_size = ret; block_size 3455 sound/soc/intel/skylake/skl-topology.c block_size); block_size 258 sound/spi/at73c213.c int block_size; block_size 260 sound/spi/at73c213.c block_size = frames_to_bytes(runtime, runtime->period_size); block_size 269 sound/spi/at73c213.c (long)runtime->dma_addr + block_size); block_size 363 sound/spi/at73c213.c int block_size; block_size 369 sound/spi/at73c213.c block_size = frames_to_bytes(runtime, runtime->period_size); block_size 380 sound/spi/at73c213.c offset = block_size * next_period; block_size 767 tools/bpf/bpftool/prog.c size_t block_size = 256; block_size 768 tools/bpf/bpftool/prog.c size_t buf_size = block_size; block_size 788 tools/bpf/bpftool/prog.c *data_ptr = malloc(block_size); block_size 795 tools/bpf/bpftool/prog.c while ((nb_read += fread(*data_ptr + nb_read, 1, block_size, f))) { block_size 803 tools/bpf/bpftool/prog.c if (nb_read > buf_size - block_size) {