Searched refs:block_size (Results 1 - 200 of 221) sorted by relevance

12

/linux-4.1.27/fs/befs/
H A Dsuper.c38 befs_sb->block_size = fs32_to_cpu(sb, disk_sb->block_size); befs_load_sb()
78 if ((befs_sb->block_size != 1024) befs_check_sb()
79 && (befs_sb->block_size != 2048) befs_check_sb()
80 && (befs_sb->block_size != 4096) befs_check_sb()
81 && (befs_sb->block_size != 8192)) { befs_check_sb()
82 befs_error(sb, "invalid blocksize: %u", befs_sb->block_size); befs_check_sb()
86 if (befs_sb->block_size > PAGE_SIZE) { befs_check_sb()
88 "than system pagesize(%lu)", befs_sb->block_size, befs_check_sb()
94 * block_shift and block_size encode the same information befs_check_sb()
98 if ((1 << befs_sb->block_shift) != befs_sb->block_size) { befs_check_sb()
99 befs_error(sb, "block_shift disagrees with block_size. " befs_check_sb()
H A Dbefs.h33 u32 block_size; member in struct:befs_sb_info
140 return BEFS_SB(sb)->block_size / sizeof (befs_disk_inode_addr); befs_iaddrs_per_block()
152 return BEFS_SB(sb)->block_size * run.len; befs_brun_size()
H A Ddebug.c167 befs_debug(sb, " block_size %u", fs32_to_cpu(sb, sup->block_size)); befs_dump_super_block()
H A Dbefs_fs_types.h117 fs32 block_size; member in struct:__anon10755
H A Ddatastream.c142 plen = ((bytes_read + BEFS_SB(sb)->block_size) < len) ? befs_read_lsymlink()
143 BEFS_SB(sb)->block_size : len - bytes_read; befs_read_lsymlink()
176 if (ds->size & (befs_sb->block_size - 1)) befs_count_blocks()
202 dbl_bytes / (befs_sb->block_size * BEFS_DBLINDIR_BRUN_LEN); befs_count_blocks()
H A Dlinuxvfs.c383 inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE; befs_iget()
394 num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE); befs_iget()
850 sb_set_blocksize(sb, (ulong) befs_sb->block_size); befs_fill_super()
/linux-4.1.27/drivers/s390/char/
H A Dtape_char.c97 tapechar_check_idalbuffer(struct tape_device *device, size_t block_size) tapechar_check_idalbuffer() argument
102 device->char_data.idal_buf->size == block_size) tapechar_check_idalbuffer()
105 if (block_size > MAX_BLOCKSIZE) { tapechar_check_idalbuffer()
107 block_size, MAX_BLOCKSIZE); tapechar_check_idalbuffer()
112 new = idal_buffer_alloc(block_size, 0); tapechar_check_idalbuffer()
132 size_t block_size; tapechar_read() local
148 if (device->char_data.block_size != 0) { tapechar_read()
149 if (count < device->char_data.block_size) { tapechar_read()
154 block_size = device->char_data.block_size; tapechar_read()
156 block_size = count; tapechar_read()
159 rc = tapechar_check_idalbuffer(device, block_size); tapechar_read()
163 DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size); tapechar_read()
165 request = device->discipline->read_block(device, block_size); tapechar_read()
171 rc = block_size - request->rescnt; tapechar_read()
190 size_t block_size; tapechar_write() local
198 if (device->char_data.block_size != 0) { tapechar_write()
199 if (count < device->char_data.block_size) { tapechar_write()
204 block_size = device->char_data.block_size; tapechar_write()
205 nblocks = count / block_size; tapechar_write()
207 block_size = count; tapechar_write()
211 rc = tapechar_check_idalbuffer(device, block_size); tapechar_write()
215 DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size); tapechar_write()
218 request = device->discipline->write_block(device, block_size); tapechar_write()
226 data, block_size)) { tapechar_write()
234 block_size - request->rescnt); tapechar_write()
235 written += block_size - request->rescnt; tapechar_write()
238 data += block_size; tapechar_write()
406 ((device->char_data.block_size << MT_ST_BLKSIZE_SHIFT) __tapechar_ioctl()
H A Dtape_proc.c60 if (device->char_data.block_size == 0) tape_proc_show()
63 seq_printf(m, "%i\t", device->char_data.block_size); tape_proc_show()
H A Dtape_std.c224 * Just set block_size to 0. tapechar_read/tapechar_write tape_std_mtsetblk()
228 device->char_data.block_size = 0; tape_std_mtsetblk()
249 device->char_data.block_size = count; tape_std_mtsetblk()
251 DBF_LH(6, "new blocksize is %d\n", device->char_data.block_size); tape_std_mtsetblk()
263 device->char_data.block_size = 0; tape_std_mtreset()
H A Dtape.h174 int block_size; /* of size block_size. */ member in struct:tape_char_data
H A Dtape_core.c163 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size); tape_blocksize_show()
/linux-4.1.27/drivers/gpu/drm/nouveau/include/nvkm/core/
H A Dmm.h23 u32 block_size; member in struct:nvkm_mm
30 return mm->block_size != 0; nvkm_mm_initialised()
/linux-4.1.27/drivers/crypto/ccp/
H A Dccp-crypto-sha.c64 unsigned int block_size = ccp_do_sha_update() local
73 if (!final && (len <= block_size)) { ccp_do_sha_update()
85 rctx->hash_rem = final ? 0 : len & (block_size - 1); ccp_do_sha_update()
89 rctx->hash_cnt -= block_size; ccp_do_sha_update()
90 rctx->hash_rem = block_size; ccp_do_sha_update()
154 unsigned int block_size = ccp_sha_init() local
164 memcpy(rctx->buf, ctx->u.sha.ipad, block_size); ccp_sha_init()
165 rctx->buf_count = block_size; ccp_sha_init()
245 unsigned int block_size = crypto_shash_blocksize(shash); ccp_sha_setkey() local
257 if (key_len > block_size) { ccp_sha_setkey()
275 for (i = 0; i < block_size; i++) { ccp_sha_setkey()
280 sg_init_one(&ctx->u.sha.opad_sg, ctx->u.sha.opad, block_size); ccp_sha_setkey()
281 ctx->u.sha.opad_count = block_size; ccp_sha_setkey()
338 u32 block_size; member in struct:ccp_sha_def
347 .block_size = SHA1_BLOCK_SIZE,
354 .block_size = SHA224_BLOCK_SIZE,
361 .block_size = SHA256_BLOCK_SIZE,
447 base->cra_blocksize = def->block_size; ccp_register_sha_alg()
H A Dccp-crypto-aes-cmac.c65 unsigned int block_size = ccp_do_cmac_update() local
80 if (!final && (len <= block_size)) { ccp_do_cmac_update()
92 rctx->hash_rem = final ? 0 : len & (block_size - 1); ccp_do_cmac_update()
96 rctx->hash_cnt -= block_size; ccp_do_cmac_update()
97 rctx->hash_rem = block_size; ccp_do_cmac_update()
100 if (final && (rctx->null_msg || (len & (block_size - 1)))) ccp_do_cmac_update()
127 int pad_length = block_size - (len & (block_size - 1)); ccp_do_cmac_update()
H A Dccp-ops.c747 struct ccp_op *op, unsigned int block_size, ccp_prepare_data()
768 /* The data operation length will be at least block_size in length ccp_prepare_data()
772 op_len = max(op_len, block_size); ccp_prepare_data()
777 if (sg_src_len < block_size) { ccp_prepare_data()
786 op->src.u.dma.length = (blocksize_op) ? block_size : cp_len; ccp_prepare_data()
793 op->src.u.dma.length = op_len & ~(block_size - 1); ccp_prepare_data()
799 if (sg_dst_len < block_size) { ccp_prepare_data()
1500 u64 block_size, digest_size; ccp_run_sha_cmd() local
1505 block_size = SHA1_BLOCK_SIZE; ccp_run_sha_cmd()
1509 block_size = SHA224_BLOCK_SIZE; ccp_run_sha_cmd()
1513 block_size = SHA256_BLOCK_SIZE; ccp_run_sha_cmd()
1521 if (sha->opad_len != block_size) { ccp_run_sha_cmd()
1526 hmac_buf = kmalloc(block_size + digest_size, GFP_KERNEL); ccp_run_sha_cmd()
1531 sg_init_one(&sg, hmac_buf, block_size + digest_size); ccp_run_sha_cmd()
1533 scatterwalk_map_and_copy(hmac_buf, sha->opad, 0, block_size, 0); ccp_run_sha_cmd()
1534 memcpy(hmac_buf + block_size, ctx.address, digest_size); ccp_run_sha_cmd()
1542 hmac_cmd.u.sha.src_len = block_size + digest_size; ccp_run_sha_cmd()
1547 hmac_cmd.u.sha.msg_bits = (block_size + digest_size) << 3; ccp_run_sha_cmd()
746 ccp_prepare_data(struct ccp_data *src, struct ccp_data *dst, struct ccp_op *op, unsigned int block_size, bool blocksize_op) ccp_prepare_data() argument
/linux-4.1.27/drivers/net/wireless/rsi/
H A Drsi_91x_usb_ops.c41 u32 block_size = dev->tx_blk_size; rsi_copy_to_card() local
47 for (indx = 0, ii = 0; ii < num_blocks; ii++, indx += block_size) { rsi_copy_to_card()
52 block_size)) { rsi_copy_to_card()
59 base_address += block_size; rsi_copy_to_card()
62 if (len % block_size) { rsi_copy_to_card()
67 len % block_size)) { rsi_copy_to_card()
137 u32 block_size = dev->tx_blk_size; rsi_load_ta_instructions() local
160 num_blocks = (len / block_size); rsi_load_ta_instructions()
H A Drsi_91x_sdio_ops.c84 u32 block_size = dev->tx_blk_size; rsi_copy_to_card() local
96 for (indx = 0, ii = 0; ii < num_blocks; ii++, indx += block_size) { rsi_copy_to_card()
101 block_size)) { rsi_copy_to_card()
108 base_address += block_size; rsi_copy_to_card()
121 if (len % block_size) { rsi_copy_to_card()
126 len % block_size)) { rsi_copy_to_card()
177 u32 block_size = dev->tx_blk_size; rsi_load_ta_instructions() local
215 num_blocks = (len / block_size); rsi_load_ta_instructions()
H A Drsi_91x_sdio.c569 u32 block_size = dev->tx_blk_size; rsi_sdio_host_intf_write_pkt() local
576 num_blocks = len / block_size; rsi_sdio_host_intf_write_pkt()
578 if (len % block_size) rsi_sdio_host_intf_write_pkt()
581 address = (num_blocks * block_size | (queueno << 12)); rsi_sdio_host_intf_write_pkt()
582 length = num_blocks * block_size; rsi_sdio_host_intf_write_pkt()
/linux-4.1.27/fs/squashfs/
H A Dlz4_wrapper.c56 int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE); lz4_init() local
62 stream->input = vmalloc(block_size); lz4_init()
65 stream->output = vmalloc(block_size); lz4_init()
H A Dlzo_wrapper.c43 int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE); lzo_init() local
48 stream->input = vmalloc(block_size); lzo_init()
51 stream->output = vmalloc(block_size); lzo_init()
H A Dsquashfs_fs_sb.h35 int block_size; member in struct:squashfs_cache
74 unsigned int block_size; member in struct:squashfs_sb_info
H A Dsuper.c148 msblk->block_size = le32_to_cpu(sblk->block_size); squashfs_fill_super()
149 if (msblk->block_size > SQUASHFS_FILE_MAX_SIZE) squashfs_fill_super()
156 if (PAGE_CACHE_SIZE > msblk->block_size) { squashfs_fill_super()
158 "currently not supported!\n", msblk->block_size); squashfs_fill_super()
167 /* Check that block_size and block_log match */ squashfs_fill_super()
168 if (msblk->block_size != (1 << msblk->block_log)) squashfs_fill_super()
187 TRACE("Block size %d\n", msblk->block_size); squashfs_fill_super()
211 squashfs_max_decompressors(), msblk->block_size); squashfs_fill_super()
281 SQUASHFS_CACHED_FRAGMENTS, msblk->block_size); squashfs_fill_super()
361 buf->f_bsize = msblk->block_size; squashfs_statfs()
H A Dcache.c233 * size block_size. To avoid vmalloc fragmentation issues each entry
237 int block_size) squashfs_cache_init()
257 cache->block_size = block_size; squashfs_cache_init()
258 cache->pages = block_size >> PAGE_CACHE_SHIFT; squashfs_cache_init()
236 squashfs_cache_init(char *name, int entries, int block_size) squashfs_cache_init() argument
H A Dfile.c434 (msblk->block_size - 1), squashfs_readpage_fragment()
446 (i_size_read(inode) & (msblk->block_size - 1)) : squashfs_readpage_sparse()
447 msblk->block_size; squashfs_readpage_sparse()
H A Dxz_wrapper.c82 opts->dict_size = max_t(int, msblk->block_size, squashfs_xz_comp_opts()
H A Dsquashfs_fs.h249 __le32 block_size; member in struct:squashfs_super_block
/linux-4.1.27/drivers/staging/comedi/
H A Dcomedi_buf.c296 int block_size = num_bytes - count; comedi_buf_munge() local
300 if (block_size > buf_end) comedi_buf_munge()
301 block_size = buf_end; comedi_buf_munge()
305 block_size, async->munge_chan); comedi_buf_munge()
313 async->munge_chan += block_size / num_sample_bytes; comedi_buf_munge()
315 async->munge_count += block_size; comedi_buf_munge()
316 async->munge_ptr += block_size; comedi_buf_munge()
318 count += block_size; comedi_buf_munge()
431 unsigned int block_size; comedi_buf_memcpy_to() local
434 block_size = async->prealloc_bufsz - write_ptr; comedi_buf_memcpy_to()
436 block_size = num_bytes; comedi_buf_memcpy_to()
438 memcpy(async->prealloc_buf + write_ptr, data, block_size); comedi_buf_memcpy_to()
440 data += block_size; comedi_buf_memcpy_to()
441 num_bytes -= block_size; comedi_buf_memcpy_to()
455 unsigned int block_size; comedi_buf_memcpy_from() local
460 block_size = async->prealloc_bufsz - read_ptr; comedi_buf_memcpy_from()
462 block_size = nbytes; comedi_buf_memcpy_from()
464 memcpy(dest, src, block_size); comedi_buf_memcpy_from()
465 nbytes -= block_size; comedi_buf_memcpy_from()
466 dest += block_size; comedi_buf_memcpy_from()
/linux-4.1.27/drivers/md/persistent-data/
H A Ddm-btree-spine.c20 size_t block_size);
24 size_t block_size) node_prepare_for_write()
31 block_size - sizeof(__le32), node_prepare_for_write()
39 size_t block_size) node_check()
54 block_size - sizeof(__le32), node_check()
65 (sizeof(__le64) + value_size) * le32_to_cpu(h->max_entries) > block_size) { node_check()
22 node_prepare_for_write(struct dm_block_validator *v, struct dm_block *b, size_t block_size) node_prepare_for_write() argument
37 node_check(struct dm_block_validator *v, struct dm_block *b, size_t block_size) node_check() argument
H A Ddm-block-manager.h35 struct block_device *bdev, unsigned block_size,
52 void (*prepare_for_write)(struct dm_block_validator *v, struct dm_block *b, size_t block_size);
57 int (*check)(struct dm_block_validator *v, struct dm_block *b, size_t block_size);
H A Ddm-space-map-common.c24 size_t block_size) index_prepare_for_write()
30 block_size - sizeof(__le32), index_prepare_for_write()
36 size_t block_size) index_check()
48 block_size - sizeof(__le32), index_check()
74 size_t block_size) bitmap_prepare_for_write()
80 block_size - sizeof(__le32), bitmap_prepare_for_write()
86 size_t block_size) bitmap_check()
98 block_size - sizeof(__le32), bitmap_check()
215 ll->block_size = dm_bm_block_size(dm_tm_get_bm(tm)); sm_ll_init()
217 if (ll->block_size > (1 << 30)) { sm_ll_init()
222 ll->entries_per_block = (ll->block_size - sizeof(struct disk_bitmap_header)) * sm_ll_init()
22 index_prepare_for_write(struct dm_block_validator *v, struct dm_block *b, size_t block_size) index_prepare_for_write() argument
34 index_check(struct dm_block_validator *v, struct dm_block *b, size_t block_size) index_check() argument
72 bitmap_prepare_for_write(struct dm_block_validator *v, struct dm_block *b, size_t block_size) bitmap_prepare_for_write() argument
84 bitmap_check(struct dm_block_validator *v, struct dm_block *b, size_t block_size) bitmap_check() argument
H A Ddm-btree.c109 static uint32_t calc_max_entries(size_t value_size, size_t block_size) calc_max_entries() argument
114 block_size -= sizeof(struct node_header); calc_max_entries()
115 total = block_size / elt_size; calc_max_entries()
126 size_t block_size; dm_btree_empty() local
133 block_size = dm_bm_block_size(dm_tm_get_bm(info->tm)); dm_btree_empty()
134 max_entries = calc_max_entries(info->value_type.size, block_size); dm_btree_empty()
137 memset(n, 0, block_size); dm_btree_empty()
H A Ddm-space-map-common.h62 uint32_t block_size; member in struct:ll_disk
H A Ddm-block-manager.c371 unsigned block_size, dm_block_manager_create()
384 bm->bufio = dm_bufio_client_create(bdev, block_size, max_held_per_thread, dm_block_manager_create()
370 dm_block_manager_create(struct block_device *bdev, unsigned block_size, unsigned cache_size, unsigned max_held_per_thread) dm_block_manager_create() argument
/linux-4.1.27/drivers/ide/
H A Dide-gd.h33 int blocks, block_size, bs_factor; member in struct:ide_disk_obj
H A Dide-floppy.c354 lba_capacity = floppy->blocks * floppy->block_size; ide_floppy_get_flexible_disk_page()
360 floppy->blocks = floppy->block_size ? ide_floppy_get_flexible_disk_page()
361 capacity / floppy->block_size : 0; ide_floppy_get_flexible_disk_page()
438 floppy->block_size = length; ide_floppy_get_capacity()
/linux-4.1.27/fs/nfsd/
H A Dblocklayoutxdr.c93 u32 block_size) nfsd4_block_decode_layoutupdate()
124 if (bex.foff & (block_size - 1)) { nfsd4_block_decode_layoutupdate()
130 if (bex.len & (block_size - 1)) { nfsd4_block_decode_layoutupdate()
136 if (bex.soff & (block_size - 1)) { nfsd4_block_decode_layoutupdate()
92 nfsd4_block_decode_layoutupdate(__be32 *p, u32 len, struct iomap **iomapp, u32 block_size) nfsd4_block_decode_layoutupdate() argument
H A Dblocklayoutxdr.h60 u32 block_size);
H A Dblocklayout.c53 u32 block_size = (1 << inode->i_blkbits); nfsd4_block_proc_layoutget() local
59 if (seg->offset & (block_size - 1)) { nfsd4_block_proc_layoutget()
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/core/
H A Dmm.c131 s = roundup(s, mm->block_size); nvkm_mm_head()
135 e = rounddown(e, mm->block_size); nvkm_mm_head()
204 s = roundup(s, mm->block_size); nvkm_mm_tail()
208 e = rounddown(e, mm->block_size); nvkm_mm_tail()
255 BUG_ON(block != mm->block_size); nvkm_mm_init()
259 mm->block_size = block; nvkm_mm_init()
268 node->offset = roundup(offset, mm->block_size); nvkm_mm_init()
269 node->length = rounddown(offset + length, mm->block_size); nvkm_mm_init()
H A Dgpuobj.c44 if (gpuobj->heap.block_size) nvkm_gpuobj_destroy()
67 if (nv_gpuobj(pargpu)->heap.block_size) nvkm_gpuobj_create_()
/linux-4.1.27/include/linux/platform_data/
H A Ddma-dw.h42 * @block_size: Maximum block size supported by the controller
56 unsigned short block_size; member in struct:dw_dma_platform_data
/linux-4.1.27/drivers/mtd/
H A Drfd_ftl.c25 static int block_size = 0; variable
26 module_param(block_size, int, 0);
27 MODULE_PARM_DESC(block_size, "Block size to use by RFD, defaults to erase unit size");
73 u_int block_size; /* size of erase unit */ member in struct:partition
97 block->offset = part->block_size * block_no; build_block_map()
157 sectors_per_block = part->block_size / SECTOR_SIZE; scan_header()
158 part->total_blocks = (u32)part->mbd.mtd->size / part->block_size; scan_header()
203 rc = mtd_read(part->mbd.mtd, i * part->block_size, scan_header()
278 i = (u32)erase->addr / part->block_size; erase_callback()
338 erase->len = part->block_size; erase_block()
456 old_sector_block = *old_sector / part->block_size; reclaim_block()
590 block = old_addr / part->block_size; mark_sector_deleted()
591 offset = (old_addr % part->block_size) / SECTOR_SIZE - mark_sector_deleted()
770 if (block_size) rfd_ftl_add_mtd()
771 part->block_size = block_size; rfd_ftl_add_mtd()
774 printk(KERN_WARNING PREFIX "please provide block_size"); rfd_ftl_add_mtd()
777 part->block_size = mtd->erasesize; rfd_ftl_add_mtd()
H A Dsm_ftl.c200 WARN_ON(boffset >= ftl->block_size); sm_mkoffset()
205 return (zone * SM_MAX_ZONE_SIZE + block) * ftl->block_size + boffset; sm_mkoffset()
212 *boffset = do_div(offset, ftl->block_size); sm_break_offset()
380 for (boffset = 0; boffset < ftl->block_size; sm_write_block()
447 for (boffset = 0; boffset < ftl->block_size; boffset += SM_SECTOR_SIZE) sm_mark_block_bad()
465 erase.len = ftl->block_size; sm_erase_block()
522 for (boffset = 0; boffset < ftl->block_size; sm_check_block()
587 ftl->block_size = 8 * SM_SECTOR_SIZE; sm_get_media_info()
596 ftl->block_size = 8 * SM_SECTOR_SIZE; sm_get_media_info()
606 ftl->block_size = 16 * SM_SECTOR_SIZE; sm_get_media_info()
613 ftl->block_size = 16 * SM_SECTOR_SIZE; sm_get_media_info()
619 ftl->block_size = 16 * SM_SECTOR_SIZE; sm_get_media_info()
628 ftl->block_size = 32 * SM_SECTOR_SIZE; sm_get_media_info()
632 if (mtd->erasesize > ftl->block_size) sm_get_media_info()
709 for (boffset = 0 ; boffset < ftl->block_size; sm_find_cis()
720 if (boffset == ftl->block_size) sm_find_cis()
736 block * ftl->block_size + sm_find_cis()
905 /*memset(ftl->cache_data, 0xAA, ftl->block_size);*/ sm_cache_init()
950 ftl->block_size / SM_SECTOR_SIZE) { sm_cache_flush()
1164 ftl->cache_data = kzalloc(ftl->block_size, GFP_KERNEL); sm_add_mtd()
1183 trans->size = (ftl->block_size * ftl->max_lba * ftl->zone_count) >> 9; sm_add_mtd()
1204 ftl->block_size); sm_add_mtd()
H A Dsm_ftl.h35 int block_size; /* block size in bytes */ member in struct:sm_ftl
/linux-4.1.27/drivers/target/
H A Dtarget_core_sbc.c76 buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff; sbc_emulate_readcapacity()
77 buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff; sbc_emulate_readcapacity()
78 buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff; sbc_emulate_readcapacity()
79 buf[7] = dev->dev_attrib.block_size & 0xff; sbc_emulate_readcapacity()
111 buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff; sbc_emulate_readcapacity_16()
112 buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff; sbc_emulate_readcapacity_16()
113 buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff; sbc_emulate_readcapacity_16()
114 buf[11] = dev->dev_attrib.block_size & 0xff; sbc_emulate_readcapacity_16()
188 return cmd->se_dev->dev_attrib.block_size * sectors; sbc_get_size()
424 unsigned int block_size = dev->dev_attrib.block_size; compare_and_write_callback() local
425 unsigned int compare_len = (nlbas * block_size); compare_and_write_callback()
502 len = cmd->t_task_nolb * block_size; compare_and_write_callback()
510 if (block_size < PAGE_SIZE) { compare_and_write_callback()
511 sg_set_page(&write_sg[i], m.page, block_size, compare_and_write_callback()
512 m.piter.sg->offset + block_size); compare_and_write_callback()
515 sg_set_page(&write_sg[i], m.page, block_size, compare_and_write_callback()
518 len -= block_size; compare_and_write_callback()
581 * Reset cmd->data_length to individual block_size in order to not sbc_compare_and_write()
585 cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size; sbc_compare_and_write()
732 cmd->data_length = sectors * dev->dev_attrib.block_size; sbc_check_prot()
1199 for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) { sbc_dif_generate()
1210 dev->dev_attrib.block_size)); sbc_dif_generate()
1236 int block_size = dev->dev_attrib.block_size; sbc_dif_v1_verify() local
1242 csum = cpu_to_be16(crc_t10dif(p, block_size)); sbc_dif_v1_verify()
1334 for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) { sbc_dif_verify_write()
1392 for (j = 0; j < dsg->length; j += dev->dev_attrib.block_size) { __sbc_dif_verify_read()
H A Dtarget_core_iblock.c220 u32 block_size = bdev_logical_block_size(bd); iblock_emulate_read_cap_with_block_size() local
222 if (block_size == dev->dev_attrib.block_size) iblock_emulate_read_cap_with_block_size()
225 switch (block_size) { iblock_emulate_read_cap_with_block_size()
227 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
241 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
256 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
271 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
475 sg->length != cmd->se_dev->dev_attrib.block_size) { iblock_execute_write_same()
477 " block_size: %u\n", cmd->t_data_nents, sg->length, iblock_execute_write_same()
478 cmd->se_dev->dev_attrib.block_size); iblock_execute_write_same()
651 bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) * iblock_alloc_bip()
714 if (dev->dev_attrib.block_size == 4096) iblock_execute_rw()
716 else if (dev->dev_attrib.block_size == 2048) iblock_execute_rw()
718 else if (dev->dev_attrib.block_size == 1024) iblock_execute_rw()
720 else if (dev->dev_attrib.block_size == 512) iblock_execute_rw()
724 " %u\n", dev->dev_attrib.block_size); iblock_execute_rw()
H A Dtarget_core_rd.c267 static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size) rd_build_prot_space() argument
279 * tot sg needed = rd_page_count * (PGSZ/block_size) * rd_build_prot_space()
280 * (prot_length/block_size) + pad rd_build_prot_space()
283 total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1; rd_build_prot_space()
416 u32 sectors = cmd->data_length / se_dev->dev_attrib.block_size; rd_do_prot_rw()
497 tmp = cmd->t_task_lba * se_dev->dev_attrib.block_size; rd_execute_rw()
664 dev->dev_attrib.block_size) - 1; rd_get_blocks()
677 dev->dev_attrib.block_size); rd_init_prot()
H A Dtarget_core_file.c272 prot_size = (cmd->data_length / se_dev->dev_attrib.block_size) * fd_do_prot_rw()
329 loff_t pos = (cmd->t_task_lba * se_dev->dev_attrib.block_size); fd_do_rw()
406 start = cmd->t_task_lba * dev->dev_attrib.block_size; fd_execute_sync_cache()
433 loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size; fd_execute_write_same()
451 cmd->t_data_sg[0].length != cmd->se_dev->dev_attrib.block_size) { fd_execute_write_same()
453 " block_size: %u\n", fd_execute_write_same()
456 cmd->se_dev->dev_attrib.block_size); fd_execute_write_same()
469 len += se_dev->dev_attrib.block_size; fd_execute_write_same()
562 loff_t pos = lba * se_dev->dev_attrib.block_size; fd_do_unmap()
563 unsigned int len = nolb * se_dev->dev_attrib.block_size; fd_do_unmap()
644 u32 sectors = cmd->data_length / dev->dev_attrib.block_size; fd_execute_rw()
660 u32 sectors = cmd->data_length / dev->dev_attrib.block_size; fd_execute_rw()
686 dev->dev_attrib.block_size; fd_execute_rw()
827 return div_u64(dev_size - dev->dev_attrib.block_size, fd_get_blocks()
828 dev->dev_attrib.block_size); fd_get_blocks()
871 int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size; fd_format_prot()
H A Dtarget_core_device.c636 static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size) se_dev_align_max_sectors() argument
644 alignment = max(1ul, PAGE_SIZE / block_size); se_dev_align_max_sectors()
1155 int se_dev_set_block_size(struct se_device *dev, u32 block_size) se_dev_set_block_size() argument
1158 pr_err("dev[%p]: Unable to change SE Device block_size" se_dev_set_block_size()
1164 if ((block_size != 512) && se_dev_set_block_size()
1165 (block_size != 1024) && se_dev_set_block_size()
1166 (block_size != 2048) && se_dev_set_block_size()
1167 (block_size != 4096)) { se_dev_set_block_size()
1170 dev, block_size); se_dev_set_block_size()
1174 dev->dev_attrib.block_size = block_size; se_dev_set_block_size()
1175 pr_debug("dev[%p]: SE Device block_size changed to %u\n", se_dev_set_block_size()
1176 dev, block_size); se_dev_set_block_size()
1180 dev->dev_attrib.max_bytes_per_io / block_size; se_dev_set_block_size()
1567 dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size; target_configure_device()
H A Dtarget_core_spc.c525 put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]); spc_emulate_evpd_b0()
538 put_unaligned_be32(opt / dev->dev_attrib.block_size, &buf[12]); spc_emulate_evpd_b0()
949 static int spc_modesense_blockdesc(unsigned char *buf, u64 blocks, u32 block_size) spc_modesense_blockdesc() argument
954 put_unaligned_be32(block_size, buf); spc_modesense_blockdesc()
958 static int spc_modesense_long_blockdesc(unsigned char *buf, u64 blocks, u32 block_size) spc_modesense_long_blockdesc() argument
961 return spc_modesense_blockdesc(buf + 3, blocks, block_size) + 3; spc_modesense_long_blockdesc()
968 put_unaligned_be32(block_size, buf); spc_modesense_long_blockdesc()
1017 u32 block_size = dev->dev_attrib.block_size; spc_emulate_modesense() local
1022 blocks, block_size); spc_emulate_modesense()
1026 blocks, block_size); spc_emulate_modesense()
1030 block_size); spc_emulate_modesense()
H A Dtarget_core_xcopy.c651 u32 length = (src_sectors * src_dev->dev_attrib.block_size); target_xcopy_read_source()
711 u32 length = (dst_sectors * dst_dev->dev_attrib.block_size); target_xcopy_write_destination()
831 copied_nolb, copied_nolb * dst_dev->dev_attrib.block_size); target_xcopy_do_work()
904 if (xop->src_dev->dev_attrib.block_size != target_do_xcopy()
905 xop->dst_dev->dev_attrib.block_size) { target_do_xcopy()
906 pr_err("XCOPY: Non matching src_dev block_size: %u + dst_dev" target_do_xcopy()
907 " block_size: %u currently unsupported\n", target_do_xcopy()
908 xop->src_dev->dev_attrib.block_size, target_do_xcopy()
909 xop->dst_dev->dev_attrib.block_size); target_do_xcopy()
H A Dtarget_core_user.c1034 return div_u64(udev->dev_size - dev->dev_attrib.block_size, tcmu_get_blocks()
1035 dev->dev_attrib.block_size); tcmu_get_blocks()
H A Dtarget_core_transport.c844 dev->dev_attrib.block_size, transport_dump_dev_state()
1127 if (dev->dev_attrib.block_size != 512) { target_cmd_size_check()
1767 sectors = cmd->data_length >> ilog2(cmd->se_dev->dev_attrib.block_size); target_write_prot_action()
2346 cmd->se_dev->dev_attrib.block_size; transport_generic_new_cmd()
2376 cmd->se_dev->dev_attrib.block_size; transport_generic_new_cmd()
/linux-4.1.27/block/partitions/
H A Dmac.h39 __be16 block_size; member in struct:mac_driver_desc
H A Dmac.c51 secsize = be16_to_cpu(md->block_size); mac_partition()
H A Dibm.c255 blocksize = label->cms.block_size; find_cms1_partitions()
/linux-4.1.27/drivers/gpu/drm/vmwgfx/
H A Dsvga3d_surfacedefs.h208 surf_size_struct block_size; member in struct:svga3d_surface_desc
754 surf_size_struct *block_size) svga3dsurface_get_size_in_blocks()
756 block_size->width = DIV_ROUND_UP(pixel_size->width, svga3dsurface_get_size_in_blocks()
757 desc->block_size.width); svga3dsurface_get_size_in_blocks()
758 block_size->height = DIV_ROUND_UP(pixel_size->height, svga3dsurface_get_size_in_blocks()
759 desc->block_size.height); svga3dsurface_get_size_in_blocks()
760 block_size->depth = DIV_ROUND_UP(pixel_size->depth, svga3dsurface_get_size_in_blocks()
761 desc->block_size.depth); svga3dsurface_get_size_in_blocks()
870 const u32 bw = desc->block_size.width, bh = desc->block_size.height; svga3dsurface_get_pixel_offset()
871 const u32 bd = desc->block_size.depth; svga3dsurface_get_pixel_offset()
752 svga3dsurface_get_size_in_blocks(const struct svga3d_surface_desc *desc, const surf_size_struct *pixel_size, surf_size_struct *block_size) svga3dsurface_get_size_in_blocks() argument
/linux-4.1.27/drivers/net/wireless/cw1200/
H A Dfwio.c185 size_t block_size; cw1200_load_firmware_cw1200() local
211 tx_size = block_size = min_t(size_t, firmware->size - put, cw1200_load_firmware_cw1200()
214 memcpy(buf, &firmware->data[put], block_size); cw1200_load_firmware_cw1200()
215 if (block_size < DOWNLOAD_BLOCK_SIZE) { cw1200_load_firmware_cw1200()
216 memset(&buf[block_size], 0, cw1200_load_firmware_cw1200()
217 DOWNLOAD_BLOCK_SIZE - block_size); cw1200_load_firmware_cw1200()
233 put += block_size; cw1200_load_firmware_cw1200()
/linux-4.1.27/drivers/gpu/drm/gma500/
H A Dintel_bios.c152 u16 *block_ptr, block_size; get_blocksize() local
155 block_size = *block_ptr; get_blocksize()
156 return block_size; get_blocksize()
343 u16 block_size; parse_sdvo_device_mapping() local
361 block_size = get_blocksize(p_defs); parse_sdvo_device_mapping()
363 child_device_num = (block_size - sizeof(*p_defs)) / parse_sdvo_device_mapping()
453 u16 block_size; parse_device_mapping() local
471 block_size = get_blocksize(p_defs); parse_device_mapping()
473 child_device_num = (block_size - sizeof(*p_defs)) / parse_device_mapping()
H A Dintel_bios.h241 * number = (block_size - sizeof(bdb_general_definitions))/
/linux-4.1.27/drivers/scsi/esas2r/
H A Desas2r_targdb.c146 || dc->block_size == 0) { esas2r_targ_db_add_raid()
156 t->block_size = dc->block_size; esas2r_targ_db_add_raid()
158 t->inter_block = dc->interleave / dc->block_size; esas2r_targ_db_add_raid()
205 t->block_size = 0; esas2r_targ_db_add_pthru()
H A Desas2r_main.c1414 d->block_size = le32_to_cpu(d->block_size); esas2r_nuxi_mgt_data()
1442 g->block_size = le32_to_cpu(g->block_size); esas2r_nuxi_mgt_data()
1462 p->block_size = le32_to_cpu(p->block_size); esas2r_nuxi_mgt_data()
H A Datvda.h195 u32 block_size; member in struct:atto_vda_devinfo
292 u32 block_size; member in struct:atto_vda_devinfo2
355 u32 block_size; member in struct:atto_vda_grp_info
469 u32 block_size; member in struct:atto_vdapart_info
H A Desas2r_disc.c656 dc->block_size = le32_to_cpu(grpinfo->block_size); esas2r_disc_raid_grp_info_cb()
1109 dc->block_size = luevt->id.tgtlun_raid.dwblock_size; esas2r_disc_dev_add()
1112 dc->block_size = 0; esas2r_disc_dev_add()
H A Desas2r.h637 u32 block_size; member in struct:esas2r_target
733 u32 block_size; member in struct:esas2r_disc_context
H A Desas2r_io.c596 sgc->length = startlba * t->block_size; esas2r_build_sg_list_prd()
/linux-4.1.27/drivers/dma/
H A Dcoh901318_lli.c199 size_t block_size = MAX_DMA_PACKET_SIZE; coh901318_lli_fill_single() local
209 block_size = MAX_DMA_PACKET_SIZE/2; coh901318_lli_fill_single()
211 s -= block_size; coh901318_lli_fill_single()
218 src += block_size; coh901318_lli_fill_single()
220 dst += block_size; coh901318_lli_fill_single()
/linux-4.1.27/drivers/md/
H A Ddm-bufio.c93 unsigned block_size; member in struct:dm_bufio_client
375 if (c->block_size <= DM_BUFIO_BLOCK_SIZE_SLAB_LIMIT) { alloc_buffer_data()
380 if (c->block_size <= DM_BUFIO_BLOCK_SIZE_GFP_LIMIT && alloc_buffer_data()
402 ptr = __vmalloc(c->block_size, gfp_mask | __GFP_HIGHMEM, PAGE_KERNEL); alloc_buffer_data()
455 adjust_total_allocated(b->data_mode, (long)c->block_size); alloc_buffer()
467 adjust_total_allocated(b->data_mode, -(long)c->block_size); free_buffer()
564 .count = b->c->block_size >> SECTOR_SHIFT, use_dmio()
618 len = b->c->block_size; use_inline_bio()
629 BUG_ON(b->c->block_size <= PAGE_SIZE); use_inline_bio()
647 if (b->c->block_size <= DM_BUFIO_INLINE_VECS * PAGE_SIZE && submit_io()
1420 return c->block_size; dm_bufio_get_block_size()
1513 return retain_bytes / c->block_size; get_retain_buffers()
1574 struct dm_bufio_client *dm_bufio_client_create(struct block_device *bdev, unsigned block_size, dm_bufio_client_create() argument
1583 BUG_ON(block_size < 1 << SECTOR_SHIFT || dm_bufio_client_create()
1584 (block_size & (block_size - 1))); dm_bufio_client_create()
1594 c->block_size = block_size; dm_bufio_client_create()
1595 c->sectors_per_block_bits = ffs(block_size) - 1 - SECTOR_SHIFT; dm_bufio_client_create()
1596 c->pages_per_block_bits = (ffs(block_size) - 1 >= PAGE_SHIFT) ? dm_bufio_client_create()
1597 ffs(block_size) - 1 - PAGE_SHIFT : 0; dm_bufio_client_create()
1598 c->blocks_per_page_bits = (ffs(block_size) - 1 < PAGE_SHIFT ? dm_bufio_client_create()
1599 PAGE_SHIFT - (ffs(block_size) - 1) : 0); dm_bufio_client_create()
1628 DM_BUFIO_CACHE_NAME(c) = kasprintf(GFP_KERNEL, "dm_bufio_cache-%u", c->block_size); dm_bufio_client_create()
1638 c->block_size, dm_bufio_client_create()
1639 c->block_size, 0, NULL); dm_bufio_client_create()
H A Ddm-cache-policy-internal.h112 sector_t origin_size, sector_t block_size);
H A Ddm-era-target.c266 dm_block_t block_size; member in struct:era_metadata
498 disk->data_block_size = cpu_to_le32(md->block_size); prepare_superblock()
532 * Assumes block_size and the infos are set.
576 md->block_size = le32_to_cpu(disk->data_block_size); open_metadata()
775 sector_t block_size, metadata_open()
785 md->block_size = block_size; metadata_open()
1414 static bool valid_block_size(dm_block_t block_size) valid_block_size() argument
1416 bool greater_than_zero = block_size > 0; valid_block_size()
1417 bool multiple_of_min_block_size = (block_size & (MIN_BLOCK_SIZE - 1)) == 0; valid_block_size()
774 metadata_open(struct block_device *bdev, sector_t block_size, bool may_format) metadata_open() argument
H A Ddm-bufio.h24 dm_bufio_client_create(struct block_device *bdev, unsigned block_size,
H A Ddm-cache-target.c2007 uint32_t block_size; member in struct:cache_args
2111 unsigned long block_size; parse_block_size() local
2116 if (kstrtoul(dm_shift_arg(as), 10, &block_size) || !block_size || parse_block_size()
2117 block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS || parse_block_size()
2118 block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS || parse_block_size()
2119 block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) { parse_block_size()
2124 if (block_size > ca->cache_sectors) { parse_block_size()
2129 ca->block_size = block_size; parse_block_size()
2389 origin_blocks = block_div(origin_blocks, ca->block_size); cache_create()
2392 cache->sectors_per_block = ca->block_size; cache_create()
2398 if (ca->block_size & (ca->block_size - 1)) { cache_create()
2402 cache_size = block_div(cache_size, ca->block_size); cache_create()
2405 cache->sectors_per_block_shift = __ffs(ca->block_size); cache_create()
2423 ca->block_size, may_format, cache_create()
2867 dm_block_t block_size; member in struct:discard_load_info
2888 b = li->discard_begin * li->block_size; set_discard_range()
2889 e = li->discard_end * li->block_size; set_discard_range()
2913 li->block_size = discard_block_size; load_discard()
H A Ddm-thin-metadata.c226 size_t block_size) sb_prepare_for_write()
232 block_size - sizeof(__le32), sb_prepare_for_write()
238 size_t block_size) sb_check()
258 block_size - sizeof(__le32), sb_check()
382 unsigned block_size = dm_bm_block_size(bm) / sizeof(__le64); __superblock_all_zeroes() local
393 for (i = 0; i < block_size; i++) { __superblock_all_zeroes()
224 sb_prepare_for_write(struct dm_block_validator *v, struct dm_block *b, size_t block_size) sb_prepare_for_write() argument
236 sb_check(struct dm_block_validator *v, struct dm_block *b, size_t block_size) sb_check() argument
H A Ddm-thin.c2415 static bool is_factor(sector_t block_size, uint32_t n) is_factor() argument
2417 return !sector_div(block_size, n); is_factor()
2429 sector_t block_size = pool->sectors_per_block << SECTOR_SHIFT; disable_passdown_if_not_supported() local
2442 else if (data_limits->discard_granularity > block_size) disable_passdown_if_not_supported()
2445 else if (!is_factor(block_size, data_limits->discard_granularity)) disable_passdown_if_not_supported()
2525 unsigned long block_size, pool_create()
2534 pmd = dm_pool_metadata_open(metadata_dev, block_size, format_device); pool_create()
2548 pool->sectors_per_block = block_size; pool_create()
2549 if (block_size & (block_size - 1)) pool_create()
2552 pool->sectors_per_block_shift = __ffs(block_size); pool_create()
2668 unsigned long block_size, int read_only, __pool_find()
2690 pool = pool_create(pool_md, metadata_dev, block_size, read_only, error); __pool_find()
2848 unsigned long block_size; pool_ctr() local
2891 if (kstrtoul(argv[2], 10, &block_size) || !block_size || pool_ctr()
2892 block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS || pool_ctr()
2893 block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS || pool_ctr()
2894 block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) { pool_ctr()
2913 block_size, pf.mode == PM_READ_ONLY, &ti->error, &pool_created); pool_ctr()
2523 pool_create(struct mapped_device *pool_md, struct block_device *metadata_dev, unsigned long block_size, int read_only, char **error) pool_create() argument
2666 __pool_find(struct mapped_device *pool_md, struct block_device *metadata_dev, unsigned long block_size, int read_only, char **error, int *created) __pool_find() argument
H A Ddm-cache-policy.h254 sector_t block_size);
/linux-4.1.27/drivers/block/rsxx/
H A Dconfig.c36 cfg->data.block_size = RSXX_HW_BLK_SIZE; initialize_config()
194 dev_dbg(CARD_TO_DEV(card), "block_size: x%08x\n", rsxx_load_config()
195 card->config.data.block_size); rsxx_load_config()
H A Drsxx_cfg.h44 __u32 block_size; member in struct:card_cfg_data
H A Ddev.c278 blk_size = card->config.data.block_size; rsxx_setup_dev()
/linux-4.1.27/fs/isofs/
H A Dcompress.c52 int i, block_size = block_end - block_start; zisofs_uncompress_block() local
57 int needblocks = (block_size + (block_start & bufmask) + bufmask) zisofs_uncompress_block()
64 if (block_size > deflateBound(1UL << zisofs_block_shift)) { zisofs_uncompress_block()
69 if (block_size == 0) { zisofs_uncompress_block()
141 block_size); zisofs_uncompress_block()
142 block_size -= stream.avail_in; zisofs_uncompress_block()
/linux-4.1.27/include/target/
H A Dtarget_core_backend_configfs.h97 DEF_TB_DEV_ATTRIB(_backend, block_size); \
98 TB_DEV_ATTR(_backend, block_size, S_IRUGO | S_IWUSR); \
H A Dtarget_core_base.h696 u32 block_size; member in struct:se_dev_attrib
/linux-4.1.27/drivers/misc/c2port/
H A Dcore.c332 return sprintf(buf, "%d\n", ops->block_size); c2port_show_flash_block_size()
342 return sprintf(buf, "%d\n", ops->blocks_num * ops->block_size); c2port_show_flash_size()
638 if (offset >= ops->block_size * ops->blocks_num) __c2port_read_flash_data()
641 if (ops->block_size * ops->blocks_num - offset < nread) __c2port_read_flash_data()
642 nread = ops->block_size * ops->blocks_num - offset; __c2port_read_flash_data()
752 if (ops->block_size * ops->blocks_num - offset < nwrite) __c2port_write_flash_data()
753 nwrite = ops->block_size * ops->blocks_num - offset; __c2port_write_flash_data()
756 if (offset >= ops->block_size * ops->blocks_num) __c2port_write_flash_data()
925 bin_attr_flash_data.size = ops->blocks_num * ops->block_size; c2port_device_register()
946 name, ops->blocks_num, ops->block_size, c2port_device_register()
947 ops->blocks_num * ops->block_size); c2port_device_register()
H A Dc2port-duramar2150.c105 .block_size = 512, /* bytes */
/linux-4.1.27/drivers/scsi/
H A Dst.c638 if (STp->block_size == 0) write_behind_check()
641 STps->drv_block += STbuffer->writing / STp->block_size; write_behind_check()
729 blks = transfer / STp->block_size; st_flush_write_buffer()
796 if (STp->block_size == 0) flush_buffer()
800 (STp->buffer)->read_pointer) / STp->block_size - flush_buffer()
801 ((STp->buffer)->read_pointer + STp->block_size - 1) / flush_buffer()
802 STp->block_size; flush_buffer()
846 STm->default_blksize != STp->block_size) { set_mode_densblk()
850 arg |= STp->block_size; set_mode_densblk()
1047 STp->block_size = 0; check_tape()
1098 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ check_tape()
1112 STp->block_size = (STp->buffer)->b_data[9] * 65536 + check_tape()
1134 if (STp->block_size > 0) check_tape()
1136 (STp->buffer)->buffer_size / STp->block_size; check_tape()
1142 STp->block_size, (STp->buffer)->buffer_size, check_tape()
1481 if (STp->block_size == 0 && STp->max_block > 0 && rw_checks()
1529 if (STp->block_size) setup_buffering()
1530 bufsize = STp->block_size > st_fixed_buffer_size ? setup_buffering()
1531 STp->block_size : st_fixed_buffer_size; setup_buffering()
1548 if (STp->block_size)
1549 STbp->buffer_blocks = bufsize / STp->block_size;
1596 if (STp->block_size != 0 && (count % STp->block_size) != 0) { st_write()
1655 if (STp->block_size != 0 && st_write()
1671 cmd[1] = (STp->block_size != 0); st_write()
1682 if (STp->block_size == 0) st_write()
1685 do_count = STbp->buffer_blocks * STp->block_size - st_write()
1700 async_write = STp->block_size == 0 && !STbp->do_dio && st_write()
1703 if (STp->block_size != 0 && STm->do_buffer_writes && st_write()
1713 if (STp->block_size == 0) st_write()
1720 blks /= STp->block_size; st_write()
1721 transfer = blks * STp->block_size; st_write()
1751 else if (STp->block_size == 0 && st_write()
1756 if (STp->block_size != 0) st_write()
1757 undone *= STp->block_size; st_write()
1763 if (STp->block_size) st_write()
1764 blks = (transfer - undone) / STp->block_size; st_write()
1770 if (STp->block_size == 0 || st_write()
1785 STp->block_size; st_write()
1815 if (STp->block_size == 0) st_write()
1873 if (STp->block_size == 0) read_tape()
1878 bytes = blks * STp->block_size; read_tape()
1883 blks = bytes / STp->block_size; read_tape()
1884 bytes = blks * STp->block_size; read_tape()
1890 cmd[1] = (STp->block_size != 0); read_tape()
1931 if (STp->block_size == 0 && read_tape()
1936 if (STp->block_size == 0 && read_tape()
1948 } else if (STp->block_size == 0) { read_tape()
1964 STp->block_size; read_tape()
1980 if (STp->block_size == 0) read_tape()
1984 bytes - transfer * STp->block_size; read_tape()
1993 if (STp->block_size == 0) read_tape()
1997 bytes - transfer * STp->block_size; read_tape()
2035 if (STp->block_size == 0)
2038 STps->drv_block += STbp->buffer_bytes / STp->block_size; st_read()
2067 if (STp->block_size != 0 && (count % STp->block_size) != 0) { st_read()
2154 if (STp->block_size == 0) st_read()
2887 ltmp = STp->block_size; st_int_ioctl()
2933 STp->block_size = arg & MT_ST_BLKSIZE_MASK; st_int_ioctl()
2934 if (STp->block_size != 0) { st_int_ioctl()
2936 (STp->buffer)->buffer_size / STp->block_size; st_int_ioctl()
3611 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | st_ioctl()
3615 if (STp->block_size != 0) { st_ioctl()
3618 (STp->buffer)->buffer_bytes / STp->block_size; st_ioctl()
3622 STp->block_size - 1) / STp->block_size; st_ioctl()
3653 (STm->do_buffer_writes && STp->block_size != 0) || st_ioctl()
H A Dosst.c727 if (STp->block_size != blk_sz && blk_sz > 0) { osst_verify_frame()
731 STp->block_size<1024?STp->block_size:STp->block_size/1024, osst_verify_frame()
732 STp->block_size<1024?'b':'k'); osst_verify_frame()
733 STp->block_size = blk_sz; osst_verify_frame()
1280 STp->block_size<1024?STp->block_size:STp->block_size/1024, osst_seek_logical_blk()
1281 STp->block_size<1024?'b':'k'); osst_seek_logical_blk()
1286 if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1; osst_seek_logical_blk()
1287 move /= (OS_DATA_SIZE / STp->block_size); osst_seek_logical_blk()
1290 frame_seq_estimate = logical_blk_num * STp->block_size / OS_DATA_SIZE; osst_seek_logical_blk()
1312 if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1; osst_seek_logical_blk()
1313 move /= (OS_DATA_SIZE / STp->block_size); osst_seek_logical_blk()
1326 STp->buffer->read_pointer = (logical_blk_num - STp->logical_blk_num) * STp->block_size; osst_seek_logical_blk()
1333 STp->buffer->buffer_bytes, STp->buffer->read_pointer / STp->block_size, osst_seek_logical_blk()
1334 STp->block_size); osst_seek_logical_blk()
1435 STp->logical_blk_num += offset / STp->block_size; osst_seek_sector()
3096 blks = (offset + STp->block_size - 1) / STp->block_size; osst_flush_write_buffer()
3120 STp->logical_blk_num - blks, STp->block_size, blks); osst_flush_write_buffer()
3208 if (STp->block_size == 0) osst_flush_buffer()
3216 backspace = ((STp->buffer)->buffer_bytes + (STp->buffer)->read_pointer) / STp->block_size - osst_flush_buffer()
3217 ((STp->buffer)->read_pointer + STp->block_size - 1 ) / STp->block_size ; osst_flush_buffer()
3286 blks = STp->buffer->buffer_bytes / STp->block_size; osst_write_frame()
3293 STp->logical_blk_num - blks, STp->block_size, blks); osst_write_frame()
3437 if (STp->block_size != 0 && (count % STp->block_size) != 0) { osst_write()
3439 name, count, STp->block_size<1024? osst_write()
3440 STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k'); osst_write()
3561 write_threshold = (STp->buffer)->buffer_blocks * STp->block_size; osst_write()
3576 do_count = (STp->buffer)->buffer_blocks * STp->block_size - osst_write()
3587 blks = do_count / STp->block_size; osst_write()
3598 STps->drv_block += (do_count - transfer) / STp->block_size; osst_write()
3650 blks = count / STp->block_size; osst_write()
3667 STp->block_size) * STp->block_size; osst_write()
3757 if ((count % STp->block_size) != 0) { osst_read()
3760 STp->block_size<1024?STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k'); osst_read()
3790 for (total = 0, special = 0; total < count - STp->block_size + 1 && !special; ) { osst_read()
3811 /* force multiple of block size, note block_size may have been adjusted */ osst_read()
3814 STp->block_size) * STp->block_size; osst_read()
3819 name, count, STp->block_size < 1024? osst_read()
3820 STp->block_size:STp->block_size/1024, osst_read()
3821 STp->block_size<1024?'b':'k'); osst_read()
3829 STp->logical_blk_num += transfer / STp->block_size; osst_read()
3830 STps->drv_block += transfer / STp->block_size; osst_read()
4308 * Note, that when reading, changing block_size is futile, osst_int_ioctl()
4311 STp->block_size = (arg & MT_ST_BLKSIZE_MASK); osst_int_ioctl()
4313 name, STp->block_size); osst_int_ioctl()
4324 (arg & MT_ST_BLKSIZE_MASK) != STp->block_size ) { osst_int_ioctl()
4651 STp->block_size = (STm->default_blksize > 0) ? __os_scsi_tape_open()
4655 STp->buffer->buffer_blocks = OS_DATA_SIZE / STp->block_size; __os_scsi_tape_open()
4740 STp->block_size = 0; __os_scsi_tape_open()
4749 STp->block_size = STp->raw ? OS_FRAME_SIZE : ( __os_scsi_tape_open()
4751 STp->buffer->buffer_blocks = STp->raw ? 1 : OS_DATA_SIZE / STp->block_size; __os_scsi_tape_open()
4759 name, STp->block_size, OS_FRAME_SIZE, (STp->buffer)->buffer_size, __os_scsi_tape_open()
5191 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | osst_ioctl()
5195 if (STp->block_size != 0) { osst_ioctl()
5197 mt_status.mt_blkno += (STp->buffer)->buffer_bytes / STp->block_size; osst_ioctl()
5200 STp->block_size - 1) / STp->block_size; osst_ioctl()
5229 if (STm->do_async_writes || (STm->do_buffer_writes && STp->block_size != 0) || osst_ioctl()
H A Dps3rom.c56 u32 block_size; member in struct:lv1_atapi_cmnd_block
110 atapi_cmnd.block_size = 1; /* transfer size is block_size * blocks */ ps3rom_atapi_request()
H A Dst.h156 int block_size; member in struct:scsi_tape
H A Ddpti.h184 u32 block_size; member in struct:adpt_device
H A Dosst.h578 int block_size; member in struct:osst_tape
H A Dhpsa_cmd.h664 __le16 block_size; /* sector size in bytes */ member in struct:bmic_identify_physical_device
H A Dgdth.h536 u16 block_size; /* cache block size */ member in struct:__anon8871
/linux-4.1.27/drivers/crypto/
H A Datmel-sha.c96 size_t block_size; member in struct:atmel_sha_reqctx
286 ctx->block_size = SHA1_BLOCK_SIZE; atmel_sha_init()
290 ctx->block_size = SHA224_BLOCK_SIZE; atmel_sha_init()
294 ctx->block_size = SHA256_BLOCK_SIZE; atmel_sha_init()
298 ctx->block_size = SHA384_BLOCK_SIZE; atmel_sha_init()
302 ctx->block_size = SHA512_BLOCK_SIZE; atmel_sha_init()
509 ctx->buflen + ctx->block_size, DMA_TO_DEVICE); atmel_sha_xmit_dma_map()
512 ctx->block_size); atmel_sha_xmit_dma_map()
568 if (!sg_is_last(sg) && !IS_ALIGNED(sg->length, ctx->block_size)) atmel_sha_update_dma_start()
569 /* size is not ctx->block_size aligned */ atmel_sha_update_dma_start()
576 /* not last sg must be ctx->block_size aligned */ atmel_sha_update_dma_start()
577 tail = length & (ctx->block_size - 1); atmel_sha_update_dma_start()
589 tail = length & (ctx->block_size - 1); atmel_sha_update_dma_start()
600 ctx->buflen + ctx->block_size, DMA_TO_DEVICE); atmel_sha_update_dma_start()
603 ctx->buflen + ctx->block_size); atmel_sha_update_dma_start()
655 ctx->buflen + ctx->block_size, DMA_TO_DEVICE); atmel_sha_update_dma_stop()
659 ctx->block_size, DMA_TO_DEVICE); atmel_sha_update_dma_stop()
H A Dn2_core.c818 static inline int cipher_descriptor_len(int nbytes, unsigned int block_size) cipher_descriptor_len() argument
822 this_len -= (nbytes & (block_size - 1)); cipher_descriptor_len()
1116 u8 block_size; member in struct:n2_cipher_tmpl
1125 .block_size = 1,
1140 .block_size = DES_BLOCK_SIZE,
1153 .block_size = DES_BLOCK_SIZE,
1167 .block_size = DES_BLOCK_SIZE,
1182 .block_size = DES_BLOCK_SIZE,
1195 .block_size = DES_BLOCK_SIZE,
1209 .block_size = DES_BLOCK_SIZE,
1223 .block_size = AES_BLOCK_SIZE,
1236 .block_size = AES_BLOCK_SIZE,
1250 .block_size = AES_BLOCK_SIZE,
1274 u8 block_size; member in struct:n2_hash_tmpl
1326 .block_size = MD5_HMAC_BLOCK_SIZE },
1334 .block_size = SHA1_BLOCK_SIZE },
1342 .block_size = SHA256_BLOCK_SIZE },
1350 .block_size = SHA224_BLOCK_SIZE },
1404 alg->cra_blocksize = tmpl->block_size; __n2_register_one_cipher()
1497 base->cra_blocksize = tmpl->block_size; __n2_register_one_ahash()
H A Datmel-aes.c88 u16 block_size; member in struct:atmel_aes_ctx
436 IS_ALIGNED(dd->in_sg->length, dd->ctx->block_size); atmel_aes_crypt_dma_start()
438 IS_ALIGNED(dd->out_sg->length, dd->ctx->block_size); atmel_aes_crypt_dma_start()
718 ctx->block_size = CFB8_BLOCK_SIZE; atmel_aes_crypt()
724 ctx->block_size = CFB16_BLOCK_SIZE; atmel_aes_crypt()
730 ctx->block_size = CFB32_BLOCK_SIZE; atmel_aes_crypt()
736 ctx->block_size = CFB64_BLOCK_SIZE; atmel_aes_crypt()
742 ctx->block_size = AES_BLOCK_SIZE; atmel_aes_crypt()
H A Datmel-tdes.c81 u16 block_size; member in struct:atmel_tdes_ctx
517 IS_ALIGNED(dd->in_sg->length, dd->ctx->block_size); atmel_tdes_crypt_start()
519 IS_ALIGNED(dd->out_sg->length, dd->ctx->block_size); atmel_tdes_crypt_start()
682 ctx->block_size = CFB8_BLOCK_SIZE; atmel_tdes_crypt()
688 ctx->block_size = CFB16_BLOCK_SIZE; atmel_tdes_crypt()
694 ctx->block_size = CFB32_BLOCK_SIZE; atmel_tdes_crypt()
700 ctx->block_size = DES_BLOCK_SIZE; atmel_tdes_crypt()
H A Dsahara.c165 * @buf: holds data for requests smaller than block_size
166 * @rembuf: used to prepare one block_size-aligned request
961 unsigned int block_size; sahara_sha_prepare_request() local
964 block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); sahara_sha_prepare_request()
970 if (!rctx->last && (len < block_size)) { sahara_sha_prepare_request()
983 /* data must always be a multiple of block_size */ sahara_sha_prepare_request()
984 hash_later = rctx->last ? 0 : len & (block_size - 1); sahara_sha_prepare_request()
/linux-4.1.27/drivers/md/bcache/
H A Dsuper.c139 sb->block_size = le16_to_cpu(s->block_size); read_super()
142 if (sb->block_size << 9 < bdev_logical_block_size(bdev)) read_super()
160 sb->block_size = le16_to_cpu(s->block_size); read_super()
175 if (!is_power_of_2(sb->block_size) || read_super()
176 sb->block_size > PAGE_SECTORS || read_super()
777 static int bcache_device_init(struct bcache_device *d, unsigned block_size, bcache_device_init() argument
843 q->limits.io_min = block_size; bcache_device_init()
844 q->limits.logical_block_size = block_size; bcache_device_init()
845 q->limits.physical_block_size = block_size; bcache_device_init()
985 if (dc->sb.block_size < c->sb.block_size) { bch_cached_dev_attach()
1123 static int cached_dev_init(struct cached_dev *dc, unsigned block_size) cached_dev_init() argument
1153 ret = bcache_device_init(&dc->disk, block_size, cached_dev_init()
1190 if (cached_dev_init(dc, sb->block_size << 9)) register_bdev()
1506 c->sb.block_size = sb->block_size; bch_cache_set_alloc()
1511 c->block_bits = ilog2(sb->block_size); bch_cache_set_alloc()
1542 iter_size = (sb->bucket_size / sb->block_size + 1) * bch_cache_set_alloc()
1737 return ca->sb.block_size == c->sb.block_size && can_attach_cache()
H A Djournal.c135 offset += blocks * ca->sb.block_size;
136 len -= blocks * ca->sb.block_size;
587 c->sb.block_size;
693 block_bytes(c)) * c->sb.block_size; journal_wait_for_write()
696 c->journal.blocks_free * c->sb.block_size, journal_wait_for_write()
H A Dsysfs.c40 read_attribute(block_size); variable
524 sysfs_hprint(block_size, block_bytes(c)); SHOW()
739 sysfs_hprint(block_size, block_bytes(ca)); SHOW()
H A Dbcache.h526 /* log2(block_size), in sectors */
709 #define block_bytes(c) ((c)->sb.block_size << 9)
H A Drequest.c383 if (bio->bi_iter.bi_sector & (c->sb.block_size - 1) || check_should_bypass()
384 bio_sectors(bio) & (c->sb.block_size - 1)) { check_should_bypass()
H A Dalloc.c640 if (b->sectors_free < c->sb.block_size) bch_alloc_sectors()
H A Dbtree.c205 iter->size = b->c->sb.bucket_size / b->c->sb.block_size; bch_btree_node_read_done()
471 atomic_long_add(set_blocks(i, block_bytes(b->c)) * b->c->sb.block_size, __bch_btree_node_write()
/linux-4.1.27/drivers/s390/block/
H A Ddasd_diag.h59 u32 block_size; member in struct:dasd_diag_init_io
H A Ddasd_diag.c109 iib->block_size = blocksize; mdsk_init_io()
436 bsize = (unsigned int) label->block_size; dasd_diag_check_device()
/linux-4.1.27/drivers/gpu/drm/i915/
H A Dintel_bios.c78 u16 *block_ptr, block_size; get_blocksize() local
81 block_size = *block_ptr; get_blocksize()
82 return block_size; get_blocksize()
441 u16 block_size = get_blocksize(general); parse_general_definitions() local
442 if (block_size >= sizeof(*general)) { parse_general_definitions()
449 block_size); parse_general_definitions()
462 u16 block_size; parse_sdvo_device_mapping() local
480 block_size = get_blocksize(p_defs); parse_sdvo_device_mapping()
482 child_device_num = (block_size - sizeof(*p_defs)) / parse_sdvo_device_mapping()
798 u16 block_size; parse_mipi() local
860 block_size = get_blocksize(sequence); parse_mipi()
881 if ((seq_data - &sequence->data[0]) > block_size) { parse_mipi()
894 if (seq_size > block_size) { parse_mipi()
1073 u16 block_size; parse_device_mapping() local
1091 block_size = get_blocksize(p_defs); parse_device_mapping()
1093 child_device_num = (block_size - sizeof(*p_defs)) / parse_device_mapping()
H A Dintel_bios.h279 * number = (block_size - sizeof(bdb_general_definitions))/
/linux-4.1.27/include/linux/
H A Dc2port.h43 unsigned short block_size; /* flash block size in bytes */ member in struct:c2port_ops
H A Dpstore_ram.h30 int block_size; member in struct:persistent_ram_ecc_info
/linux-4.1.27/sound/atmel/
H A Dac97c.c321 int block_size = frames_to_bytes(runtime, runtime->period_size); atmel_ac97c_playback_prepare() local
399 writel(block_size / 2, chip->regs + ATMEL_PDC_TCR); atmel_ac97c_playback_prepare()
400 writel(runtime->dma_addr + block_size, atmel_ac97c_playback_prepare()
402 writel(block_size / 2, chip->regs + ATMEL_PDC_TNCR); atmel_ac97c_playback_prepare()
412 int block_size = frames_to_bytes(runtime, runtime->period_size); atmel_ac97c_capture_prepare() local
490 writel(block_size / 2, chip->regs + ATMEL_PDC_RCR); atmel_ac97c_capture_prepare()
491 writel(runtime->dma_addr + block_size, atmel_ac97c_capture_prepare()
493 writel(block_size / 2, chip->regs + ATMEL_PDC_RNCR); atmel_ac97c_capture_prepare()
661 int offset, next_period, block_size; atmel_ac97c_interrupt() local
672 block_size = frames_to_bytes(runtime, atmel_ac97c_interrupt()
682 offset = block_size * next_period; atmel_ac97c_interrupt()
686 writel(block_size / 2, atmel_ac97c_interrupt()
694 block_size = frames_to_bytes(runtime, atmel_ac97c_interrupt()
704 offset = block_size * next_period; atmel_ac97c_interrupt()
708 writel(block_size / 2, atmel_ac97c_interrupt()
/linux-4.1.27/fs/pstore/
H A Dram_core.c162 int ecc_block_size = prz->ecc_info.block_size; persistent_ram_update_ecc()
205 int size = prz->ecc_info.block_size; persistent_ram_ecc_old()
216 block += prz->ecc_info.block_size; persistent_ram_ecc_old()
232 prz->ecc_info.block_size = ecc_info->block_size ?: 128; persistent_ram_init_ecc()
238 prz->ecc_info.block_size + persistent_ram_init_ecc()
H A Dram.c548 cxt->ecc_info.ecc_size, cxt->ecc_info.block_size); ramoops_probe()
/linux-4.1.27/fs/ufs/
H A Dsuper.c776 unsigned block_size, super_block_size; ufs_fill_super() local
840 uspi->s_fsize = block_size = 512; ufs_fill_super()
850 uspi->s_fsize = block_size = 512; ufs_fill_super()
860 uspi->s_fsize = block_size = 1024; ufs_fill_super()
871 uspi->s_fsize = block_size = 1024; ufs_fill_super()
883 uspi->s_fsize = block_size = 1024; ufs_fill_super()
894 uspi->s_fsize = block_size = 1024; ufs_fill_super()
909 uspi->s_fsize = block_size = 1024; ufs_fill_super()
925 uspi->s_fsize = block_size = 2048; ufs_fill_super()
941 uspi->s_fsize = block_size = 1024; ufs_fill_super()
957 uspi->s_fsize = block_size = 1024; ufs_fill_super()
976 if (!sb_set_blocksize(sb, block_size)) { ufs_fill_super()
985 ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size); ufs_fill_super()
1079 if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) { ufs_fill_super()
1082 block_size = uspi->s_fsize; ufs_fill_super()
1084 UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size); ufs_fill_super()
/linux-4.1.27/drivers/memstick/core/
H A Dms_block.h80 unsigned short block_size; member in struct:ms_boot_attr_info
174 int block_size; member in struct:msb_data
H A Dms_block.c982 sg_init_one(&sg, msb->block_buffer, msb->block_size); msb_verify_block()
994 msb->block_buffer, msb->block_size)) msb_verify_block()
1176 p->attr.block_size = be16_to_cpu(p->attr.block_size); msb_fix_boot_page_endianness()
1521 msb->cache = kzalloc(msb->block_size, GFP_KERNEL); msb_cache_init()
1548 sg_init_one(&sg, msb->cache , msb->block_size); msb_cache_flush()
1730 msb->pages_in_block = boot_block->attr.block_size * 2; msb_init_card()
1731 msb->block_size = msb->page_size * msb->pages_in_block; msb_init_card()
1739 msb->block_buffer = kzalloc(msb->block_size, GFP_KERNEL); msb_init_card()
1743 raw_size_in_megs = (msb->block_size * msb->block_count) >> 20; msb_init_card()
1813 if (page == 0 && len - offset >= msb->block_size) { msb_do_write_request()
1823 offset += msb->block_size; msb_do_write_request()
1824 *sucessfuly_written += msb->block_size; msb_do_write_request()
2270 if (msb->block_size != new_msb->block_size) msb_resume()
H A Dmspro_block.c75 __be16 block_size; member in struct:mspro_sys_info
339 be16_to_cpu(x_sys->block_size)); mspro_block_attr_show_sysinfo()
1254 capacity *= be16_to_cpu(sys_info->block_size); mspro_block_init_disk()
/linux-4.1.27/fs/reiserfs/
H A Dtail_conversion.c212 unsigned long block_size = sb->s_blocksize; indirect2direct() local
227 tail_len = (n_new_file_size & (block_size - 1)); indirect2direct()
293 return block_size - round_tail_len; indirect2direct()
316 return block_size - round_tail_len; indirect2direct()
H A Ditem_ops.c19 static int sd_bytes_number(struct item_head *ih, int block_size) sd_bytes_number() argument
122 static int direct_bytes_number(struct item_head *ih, int block_size) direct_bytes_number() argument
213 static int indirect_bytes_number(struct item_head *ih, int block_size) indirect_bytes_number() argument
215 return ih_item_len(ih) / UNFM_P_SIZE * block_size; indirect_bytes_number()
357 static int direntry_bytes_number(struct item_head *ih, int block_size) direntry_bytes_number() argument
644 static int errcatch_bytes_number(struct item_head *ih, int block_size) errcatch_bytes_number() argument
H A Dstree.c1547 int block_size = sb->s_blocksize; maybe_indirect_to_direct() local
1563 block_size - (new_file_size & (block_size - 1)); maybe_indirect_to_direct()
H A Dreiserfs.h1623 #define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
1972 #define REISERFS_MAX_NAME(block_size) 255
2627 int (*bytes_number) (struct item_head * ih, int block_size);
/linux-4.1.27/fs/ceph/
H A Dioctl.c206 dl.block_size = ceph_file_layout_su(ci->i_layout); ceph_ioctl_get_dataloc()
208 /* block_offset = object_offset % block_size */ ceph_ioctl_get_dataloc()
210 dl.block_offset = do_div(tmp, dl.block_size); ceph_ioctl_get_dataloc()
H A Dioctl.h62 __u64 block_size; /* out: block length */ member in struct:ceph_ioctl_dataloc
/linux-4.1.27/sound/oss/dmasound/
H A Ddmasound_core.c485 sq->block_size = sq->bufSize; sq_setup()
495 sq->block_size = sq->user_frag_size ; sq_setup()
496 sq->block_size *= sq_setup()
498 sq->block_size /= sq_setup()
501 sq->block_size *= dmasound.hard.speed ; sq_setup()
502 sq->block_size /= dmasound.soft.speed ; sq_setup()
506 sq->block_size += (hard_frame - 1) ; sq_setup()
507 sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */ sq_setup()
509 if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) { sq_setup()
513 sq->block_size = sq->bufSize ; sq_setup()
608 (bLeft = write_sq.block_size-write_sq.rear_size) > 0) { sq_write()
652 bLeft = write_sq.block_size; sq_write()
685 if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0) sq_poll()
1329 "write", write_sq.max_count, write_sq.block_size, state_open()
H A Ddmasound_paula.c471 : write_sq.block_size)>>1; AmiPlayNextFrame()
542 write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { AmiPlay()
647 write_sq_block_size_half = write_sq.block_size>>1; AmiWriteSqSetup()
H A Ddmasound_q40.c411 size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size); Q40PlayNextFrame()
447 if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { Q40Play()
H A Ddmasound.h222 int block_size; /* internal block size in bytes */ member in struct:sound_queue
H A Ddmasound_atari.c1177 : write_sq.block_size); AtaPlayNextFrame()
1217 write_sq.rear_size < write_sq.block_size && AtaPlay()
1232 write_sq.rear_size < write_sq.block_size && AtaPlay()
1247 write_sq.rear_size < write_sq.block_size && AtaPlay()
/linux-4.1.27/drivers/crypto/qat/qat_common/
H A Dqat_algs.c162 int block_size = crypto_shash_blocksize(ctx->hash_tfm); qat_alg_do_precomputes() local
164 char ipad[block_size]; qat_alg_do_precomputes()
165 char opad[block_size]; qat_alg_do_precomputes()
170 memset(ipad, 0, block_size); qat_alg_do_precomputes()
171 memset(opad, 0, block_size); qat_alg_do_precomputes()
175 if (auth_keylen > block_size) { qat_alg_do_precomputes()
187 for (i = 0; i < block_size; i++) { qat_alg_do_precomputes()
197 if (crypto_shash_update(shash, ipad, block_size)) qat_alg_do_precomputes()
229 if (crypto_shash_update(shash, opad, block_size)) qat_alg_do_precomputes()
258 memzero_explicit(ipad, block_size); qat_alg_do_precomputes()
259 memzero_explicit(opad, block_size); qat_alg_do_precomputes()
/linux-4.1.27/sound/isa/gus/
H A Dgus_pcm.c55 unsigned int block_size; member in struct:gus_pcm_private
138 curr = begin + (pcmp->bpos * pcmp->block_size) / runtime->channels; snd_gf1_pcm_trigger_up()
139 end = curr + (pcmp->block_size / runtime->channels); snd_gf1_pcm_trigger_up()
229 end = pcmp->memory + (((pcmp->bpos + 1) * pcmp->block_size) / runtime->channels); snd_gf1_pcm_interrupt_wave()
260 end = pcmp->bpos * pcmp->block_size; snd_gf1_pcm_interrupt_wave()
262 snd_gf1_pcm_block_change(pcmp->substream, end, pcmp->memory + (end / 2), pcmp->block_size / 2); snd_gf1_pcm_interrupt_wave()
263 snd_gf1_pcm_block_change(pcmp->substream, end + (pcmp->block_size / 2), pcmp->memory + (pcmp->dma_size / 2) + (end / 2), pcmp->block_size / 2); snd_gf1_pcm_interrupt_wave()
265 snd_gf1_pcm_block_change(pcmp->substream, end, pcmp->memory + end, pcmp->block_size); snd_gf1_pcm_interrupt_wave()
495 pcmp->block_size = snd_pcm_lib_period_bytes(substream); snd_gf1_pcm_playback_prepare()
496 pcmp->blocks = pcmp->dma_size / pcmp->block_size; snd_gf1_pcm_playback_prepare()
/linux-4.1.27/drivers/mmc/host/
H A Dvub300.c73 u8 block_size[2]; member in struct:sd_command_header
1085 vub300->cmnd.head.block_size[0] = (vub300->fbs[fn] >> 8) & 0xFF; send_command()
1086 vub300->cmnd.head.block_size[1] = (vub300->fbs[fn] >> 0) & 0xFF; send_command()
1095 vub300->cmnd.head.block_size[0] = (vub300->fbs[0] >> 8) & 0xFF; send_command()
1096 vub300->cmnd.head.block_size[1] = (vub300->fbs[0] >> 0) & 0xFF; send_command()
1109 vub300->cmnd.head.block_size[0] = send_command()
1111 vub300->cmnd.head.block_size[1] = send_command()
1116 vub300->cmnd.head.block_size[0] = send_command()
1118 vub300->cmnd.head.block_size[1] = send_command()
1138 vub300->cmnd.head.block_size[0] = (data->blksz >> 8) & 0xFF; send_command()
1139 vub300->cmnd.head.block_size[1] = (data->blksz >> 0) & 0xFF; send_command()
1155 if (vub300->cmnd.head.block_size[0] || vub300->cmnd.head.block_size[1]) { send_command()
1156 u16 block_size = vub300->cmnd.head.block_size[1] | send_command() local
1157 (vub300->cmnd.head.block_size[0] << 8); send_command()
1159 (FIRMWARE_BLOCK_BOUNDARY % block_size); send_command()
2189 vub300->cmnd.head.block_size[0] = 0x00; vub300_probe()
2190 vub300->cmnd.head.block_size[1] = 0x00; vub300_probe()
H A Dandroid-goldfish.c370 int block_size; goldfish_mmc_prepare_data() local
382 block_size = data->blksz; goldfish_mmc_prepare_data()
385 GOLDFISH_MMC_WRITE(host, MMC_BLOCK_LENGTH, block_size - 1); goldfish_mmc_prepare_data()
H A Dushc.c70 __le16 block_size; member in struct:ushc_cbw
283 ushc->cbw->block_size = cpu_to_le16(req->data->blksz); ushc_request()
285 ushc->cbw->block_size = 0; ushc_request()
H A Domap.c950 int i, use_dma = 1, block_size; mmc_omap_prepare_data() local
963 block_size = data->blksz; mmc_omap_prepare_data()
966 OMAP_MMC_WRITE(host, BLEN, block_size - 1); mmc_omap_prepare_data()
976 if ((data->sg[i].length % block_size) != 0) { mmc_omap_prepare_data()
1059 host->total_bytes_left = data->blocks * block_size; mmc_omap_prepare_data()
/linux-4.1.27/drivers/scsi/aacraid/
H A Daachba.c626 dresp->mnt[0].fileinfo.bdevinfo.block_size = 0x200; _aac_probe_container2()
627 fsa_dev_ptr->block_size = 0x200; _aac_probe_container2()
629 fsa_dev_ptr->block_size = _aac_probe_container2()
630 le32_to_cpu(dresp->mnt[0].fileinfo.bdevinfo.block_size); _aac_probe_container2()
1162 dev->fsa_dev[scmd_id(cmd)].block_size); aac_read_raw_io()
1178 dev->fsa_dev[scmd_id(cmd)].block_size); aac_read_raw_io()
1252 dev->fsa_dev[scmd_id(cmd)].block_size); aac_read_block()
1288 dev->fsa_dev[scmd_id(cmd)].block_size); aac_write_raw_io()
1307 dev->fsa_dev[scmd_id(cmd)].block_size); aac_write_raw_io()
1384 dev->fsa_dev[scmd_id(cmd)].block_size); aac_write_block()
2526 cp[8] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff; aac_scsi_cmd()
2527 cp[9] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff; aac_scsi_cmd()
2528 cp[10] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff; aac_scsi_cmd()
2529 cp[11] = (fsa_dev_ptr[cid].block_size) & 0xff; aac_scsi_cmd()
2566 cp[4] = (fsa_dev_ptr[cid].block_size >> 24) & 0xff; aac_scsi_cmd()
2567 cp[5] = (fsa_dev_ptr[cid].block_size >> 16) & 0xff; aac_scsi_cmd()
2568 cp[6] = (fsa_dev_ptr[cid].block_size >> 8) & 0xff; aac_scsi_cmd()
2569 cp[7] = (fsa_dev_ptr[cid].block_size) & 0xff; aac_scsi_cmd()
2611 (fsa_dev_ptr[cid].block_size >> 16) & 0xff; aac_scsi_cmd()
2613 (fsa_dev_ptr[cid].block_size >> 8) & 0xff; aac_scsi_cmd()
2615 fsa_dev_ptr[cid].block_size & 0xff; aac_scsi_cmd()
2700 (fsa_dev_ptr[cid].block_size >> 16) & 0xff; aac_scsi_cmd()
2702 (fsa_dev_ptr[cid].block_size >> 8) & 0xff; aac_scsi_cmd()
2704 fsa_dev_ptr[cid].block_size & 0xff; aac_scsi_cmd()
H A Daacraid.h915 u32 block_size; member in struct:fsa_dev_info
1691 __le32 block_size; member in struct:aac_blockdevinfo
/linux-4.1.27/drivers/media/usb/gspca/
H A Djl2005bcd.c50 int block_size; /* block size of camera */ member in struct:sd
364 bytes_left = buffer[0x07] * dev->block_size - act_len; jl2005c_dostream()
434 sd->block_size = 0x80; sd_config()
438 sd->block_size = 0x200; sd_config()
/linux-4.1.27/drivers/block/
H A Dcciss.c181 sector_t *total_size, unsigned int *block_size);
183 sector_t *total_size, unsigned int *block_size);
186 unsigned int block_size, InquiryData_struct *inq_buff,
1959 h->drv[drv_index]->block_size); cciss_add_disk()
1991 unsigned int block_size; cciss_update_drive_info() local
2006 &total_size, &block_size); cciss_update_drive_info()
2009 cciss_read_capacity(h, drv_index, &total_size, &block_size); cciss_update_drive_info()
2015 &total_size, &block_size); cciss_update_drive_info()
2024 cciss_geometry_inquiry(h, drv_index, total_size, block_size, cciss_update_drive_info()
2026 drvinfo->block_size = block_size; cciss_update_drive_info()
2041 drvinfo->block_size == h->drv[drv_index]->block_size && cciss_update_drive_info()
2082 h->drv[drv_index]->block_size = drvinfo->block_size; cciss_update_drive_info()
2252 h->drv[drv_index]->block_size = 512; cciss_add_controller_node()
2415 drive_info->block_size = 0; cciss_clear_drive_info()
2842 unsigned int block_size, cciss_geometry_inquiry()
2870 drv->block_size = block_size; cciss_geometry_inquiry()
2887 unsigned int *block_size) cciss_read_capacity()
2904 *block_size = be32_to_cpu(*(__be32 *) buf->block_size); cciss_read_capacity()
2908 *block_size = BLOCK_SIZE; cciss_read_capacity()
2914 sector_t *total_size, unsigned int *block_size) cciss_read_capacity_16()
2932 *block_size = be32_to_cpu(*(__be32 *) buf->block_size); cciss_read_capacity_16()
2936 *block_size = BLOCK_SIZE; cciss_read_capacity_16()
2938 dev_info(&h->pdev->dev, " blocks= %llu block_size= %d\n", cciss_read_capacity_16()
2939 (unsigned long long)*total_size+1, *block_size); cciss_read_capacity_16()
2949 unsigned int block_size; cciss_revalidate() local
2973 &total_size, &block_size); cciss_revalidate()
2976 &total_size, &block_size); cciss_revalidate()
2978 cciss_geometry_inquiry(h, logvol, total_size, block_size, cciss_revalidate()
2981 blk_queue_logical_block_size(drv->queue, drv->block_size); cciss_revalidate()
2840 cciss_geometry_inquiry(ctlr_info_t *h, int logvol, sector_t total_size, unsigned int block_size, InquiryData_struct *inq_buff, drive_info_struct *drv) cciss_geometry_inquiry() argument
2886 cciss_read_capacity(ctlr_info_t *h, int logvol, sector_t *total_size, unsigned int *block_size) cciss_read_capacity() argument
2913 cciss_read_capacity_16(ctlr_info_t *h, int logvol, sector_t *total_size, unsigned int *block_size) cciss_read_capacity_16() argument
H A Dcciss_cmd.h108 BYTE block_size[4]; /* Size of blocks in bytes */ member in struct:_ReadCapdata_struct
121 BYTE block_size[4]; /* Size of blocks in bytes */ member in struct:_ReadCapdata_struct_16
H A Dcciss.h37 int block_size; member in struct:_drive_info_struct
/linux-4.1.27/fs/ntfs/
H A Ddir.c358 dir_ni->itype.index.block_size) { ntfs_lookup_inode_by_name()
365 dir_ni->itype.index.block_size); ntfs_lookup_inode_by_name()
368 index_end = (u8*)ia + dir_ni->itype.index.block_size; ntfs_lookup_inode_by_name()
378 if (index_end > (u8*)ia + dir_ni->itype.index.block_size) { ntfs_lookup_inode_by_name()
836 dir_ni->itype.index.block_size) {
843 dir_ni->itype.index.block_size);
846 index_end = (u8*)ia + dir_ni->itype.index.block_size;
856 if (index_end > (u8*)ia + dir_ni->itype.index.block_size) {
1311 ~(s64)(ndir->itype.index.block_size - 1))); ntfs_readdir()
1327 ~(s64)(ndir->itype.index.block_size - 1)) >> ntfs_readdir()
1339 ndir->itype.index.block_size)) { ntfs_readdir()
1347 ndir->itype.index.block_size); ntfs_readdir()
1350 index_end = (u8*)ia + ndir->itype.index.block_size; ntfs_readdir()
1359 ia_start = ia_pos & ~(s64)(ndir->itype.index.block_size - 1); ntfs_readdir()
1361 if (unlikely(index_end > (u8*)ia + ndir->itype.index.block_size)) { ntfs_readdir()
H A Dinode.c410 ni->itype.index.block_size = 0; __ntfs_init_inode()
863 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size); ntfs_read_locked_inode()
864 if (ni->itype.index.block_size & ntfs_read_locked_inode()
865 (ni->itype.index.block_size - 1)) { ntfs_read_locked_inode()
868 ni->itype.index.block_size); ntfs_read_locked_inode()
871 if (ni->itype.index.block_size > PAGE_CACHE_SIZE) { ntfs_read_locked_inode()
875 ni->itype.index.block_size, ntfs_read_locked_inode()
880 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) { ntfs_read_locked_inode()
884 ni->itype.index.block_size, ntfs_read_locked_inode()
890 ffs(ni->itype.index.block_size) - 1; ntfs_read_locked_inode()
892 if (vol->cluster_size <= ni->itype.index.block_size) { ntfs_read_locked_inode()
1106 ni->itype.compressed.block_size = 1U << ntfs_read_locked_inode()
1113 block_size) - 1; ntfs_read_locked_inode()
1119 ni->itype.compressed.block_size = 0; ntfs_read_locked_inode()
1389 ni->itype.compressed.block_size = 1U << ntfs_read_locked_attr_inode()
1395 block_size) - 1; ntfs_read_locked_attr_inode()
1400 ni->itype.compressed.block_size = 0; ntfs_read_locked_attr_inode()
1582 ni->itype.index.block_size = le32_to_cpu(ir->index_block_size); ntfs_read_locked_index_inode()
1583 if (!is_power_of_2(ni->itype.index.block_size)) { ntfs_read_locked_index_inode()
1585 "two.", ni->itype.index.block_size); ntfs_read_locked_index_inode()
1588 if (ni->itype.index.block_size > PAGE_CACHE_SIZE) { ntfs_read_locked_index_inode()
1591 ni->itype.index.block_size, PAGE_CACHE_SIZE); ntfs_read_locked_index_inode()
1595 if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) { ntfs_read_locked_index_inode()
1598 ni->itype.index.block_size, NTFS_BLOCK_SIZE); ntfs_read_locked_index_inode()
1602 ni->itype.index.block_size_bits = ffs(ni->itype.index.block_size) - 1; ntfs_read_locked_index_inode()
1604 if (vol->cluster_size <= ni->itype.index.block_size) { ntfs_read_locked_index_inode()
1807 ni->itype.index.block_size = vol->mft_record_size; ntfs_read_inode_mount()
H A Dindex.c315 idx_ni->itype.index.block_size) { ntfs_index_lookup()
322 idx_ni->itype.index.block_size); ntfs_index_lookup()
325 index_end = (u8*)ia + idx_ni->itype.index.block_size; ntfs_index_lookup()
335 if (index_end > (u8*)ia + idx_ni->itype.index.block_size) { ntfs_index_lookup()
H A Dcompress.c491 unsigned long flags, block_size = sb->s_blocksize; ntfs_read_compressed_block() local
496 u32 cb_size = ni->itype.compressed.block_size; ntfs_read_compressed_block()
537 bhs_size = cb_size / block_size * sizeof(struct buffer_head *); ntfs_read_compressed_block()
651 /* Read the lcn from device in chunks of block_size bytes. */ ntfs_read_compressed_block()
723 memcpy(cb_pos, bhs[i]->b_data, block_size); ntfs_read_compressed_block()
724 cb_pos += block_size; ntfs_read_compressed_block()
H A Dinode.h104 u32 block_size; /* Size of an index block. */ member in struct:_ntfs_inode::__anon11135::__anon11136
115 u32 block_size; /* Size of a compression block member in struct:_ntfs_inode::__anon11135::__anon11137
H A Dlogfile.c734 unsigned block_size, block_size_bits; ntfs_empty_logfile() local
750 block_size = sb->s_blocksize; ntfs_empty_logfile()
812 memset(bh->b_data, -1, block_size); ntfs_empty_logfile()
H A Daops.c144 rec_size = ni->itype.index.block_size; ntfs_end_buffer_async_read()
927 unsigned int rec_size = ni->itype.index.block_size; ntfs_write_mst_block()
1303 if (ni->itype.index.block_size == PAGE_CACHE_SIZE) ntfs_write_mst_block()
1736 end = ofs + ni->itype.index.block_size; mark_ntfs_record_dirty()
H A Dattrib.c719 unsigned long block_size; load_attribute_list() local
733 block_size = sb->s_blocksize; load_attribute_list()
755 /* Read the run from device in chunks of block_size bytes. */ load_attribute_list()
767 if (al + block_size >= al_end) load_attribute_list()
769 memcpy(al, bh->b_data, block_size); load_attribute_list()
771 al += block_size; load_attribute_list()
1718 ni->itype.compressed.block_size = 1U << (a->data. ntfs_attr_make_non_resident()
1722 ffs(ni->itype.compressed.block_size) - ntfs_attr_make_non_resident()
1727 ni->itype.compressed.block_size = 0; ntfs_attr_make_non_resident()
/linux-4.1.27/drivers/mtd/onenand/
H A Donenand_base.c2242 unsigned int block_size = (1 << this->erase_shift); onenand_multiblock_erase_verify() local
2246 this->command(mtd, ONENAND_CMD_ERASE_VERIFY, addr, block_size); onenand_multiblock_erase_verify()
2255 len -= block_size; onenand_multiblock_erase_verify()
2256 addr += block_size; onenand_multiblock_erase_verify()
2271 unsigned int block_size) onenand_multiblock_erase()
2298 len -= block_size; onenand_multiblock_erase()
2299 addr += block_size; onenand_multiblock_erase()
2325 while (len > block_size && eb_count < (max_eb_count - 1)) { onenand_multiblock_erase()
2327 addr, block_size); onenand_multiblock_erase()
2328 onenand_invalidate_bufferram(mtd, addr, block_size); onenand_multiblock_erase()
2340 len -= block_size; onenand_multiblock_erase()
2341 addr += block_size; onenand_multiblock_erase()
2347 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size); onenand_multiblock_erase()
2348 onenand_invalidate_bufferram(mtd, addr, block_size); onenand_multiblock_erase()
2360 len -= block_size; onenand_multiblock_erase()
2361 addr += block_size; onenand_multiblock_erase()
2365 verify_instr.len = eb_count * block_size; onenand_multiblock_erase()
2382 * @param block_size erase block size
2389 unsigned int block_size) onenand_block_by_block_erase()
2417 this->command(mtd, ONENAND_CMD_ERASE, addr, block_size); onenand_block_by_block_erase()
2419 onenand_invalidate_bufferram(mtd, addr, block_size); onenand_block_by_block_erase()
2431 len -= block_size; onenand_block_by_block_erase()
2432 addr += block_size; onenand_block_by_block_erase()
2439 block_size = region->erasesize; onenand_block_by_block_erase()
2442 if (len & (block_size - 1)) { onenand_block_by_block_erase()
2463 unsigned int block_size; onenand_erase() local
2479 block_size = region->erasesize; onenand_erase()
2486 block_size = 1 << this->erase_shift; onenand_erase()
2489 if (unlikely((addr - region_offset) & (block_size - 1))) { onenand_erase()
2495 if (unlikely(len & (block_size - 1))) { onenand_erase()
2504 instr->len < MB_ERASE_MIN_BLK_COUNT * block_size) { onenand_erase()
2507 region, block_size); onenand_erase()
2509 ret = onenand_multiblock_erase(mtd, instr, block_size); onenand_erase()
2269 onenand_multiblock_erase(struct mtd_info *mtd, struct erase_info *instr, unsigned int block_size) onenand_multiblock_erase() argument
2386 onenand_block_by_block_erase(struct mtd_info *mtd, struct erase_info *instr, struct mtd_erase_region_info *region, unsigned int block_size) onenand_block_by_block_erase() argument
/linux-4.1.27/drivers/dma/dw/
H A Dplatform.c128 if (!of_property_read_u32(np, "block_size", &tmp)) dw_dma_parse_dt()
129 pdata->block_size = tmp; dw_dma_parse_dt()
H A Dcore.c723 dwc->block_size); dwc_prep_dma_memcpy()
820 if ((len >> mem_width) > dwc->block_size) { for_each_sg()
821 dlen = dwc->block_size << mem_width; for_each_sg()
877 if ((len >> reg_width) > dwc->block_size) { for_each_sg()
878 dlen = dwc->block_size << reg_width; for_each_sg()
1368 if (period_len > (dwc->block_size << reg_width)) dw_dma_cyclic_prep()
1634 dwc->block_size = dw_dma_probe()
1639 dwc->block_size = pdata->block_size; dw_dma_probe()
H A Dregs.h246 unsigned int block_size; member in struct:dw_dma_chan
/linux-4.1.27/include/uapi/linux/
H A Dbcache.h179 __u16 block_size; /* sectors */ member in struct:cache_sb::__anon13124::__anon13125
190 * block_size from the cache device section is still used by
/linux-4.1.27/arch/powerpc/kernel/
H A Drtas_flash.c171 unsigned long block_size, image_size; flash_list_valid() local
180 block_size = f->blocks[i].length; flash_list_valid()
181 if (block_size <= 0 || block_size > RTAS_BLK_SIZE) { flash_list_valid()
184 image_size += block_size; flash_list_valid()
/linux-4.1.27/drivers/media/platform/soc_camera/
H A Domap1_camera.c302 unsigned int block_size; set_dma_dest_params() local
306 block_size = buf->vb.size; set_dma_dest_params()
318 block_size = sg_dma_len(buf->sgbuf); set_dma_dest_params()
319 if (WARN_ON(!block_size)) { set_dma_dest_params()
324 if (unlikely(buf->bytes_left < block_size)) set_dma_dest_params()
325 block_size = buf->bytes_left; set_dma_dest_params()
330 block_size &= ~(DMA_FRAME_SIZE(vb_mode) * set_dma_dest_params()
333 buf->bytes_left -= block_size; set_dma_dest_params()
341 block_size >> (DMA_FRAME_SHIFT(vb_mode) + DMA_ELEMENT_SHIFT), set_dma_dest_params()
/linux-4.1.27/drivers/staging/comedi/drivers/
H A Dgsc_hpdi.c166 unsigned int block_size; member in struct:hpdi_private
188 for (desc = 0; (next < start || next >= start + devpriv->block_size) && gsc_hpdi_drain_dma()
191 size = devpriv->block_size / sizeof(uint32_t); gsc_hpdi_drain_dma()
476 devpriv->block_size = len; gsc_hpdi_setup_dma_descriptors()
H A Dcb_pcidas64.c1886 unsigned int block_size, requested_block_size; ai_config_block_size() local
1900 block_size = ai_fifo_size(dev) / fifo->num_segments * bytes_in_sample; ai_config_block_size()
1902 data[1] = block_size; ai_config_block_size()
/linux-4.1.27/drivers/video/fbdev/omap2/dss/
H A Dhdmi_wp.c220 r = FLD_MOD(r, aud_dma->block_size, 7, 0); hdmi_wp_audio_config_dma()
H A Dhdmi.h201 u8 block_size; member in struct:hdmi_audio_dma
H A Dhdmi4_core.c827 audio_dma.block_size = 0xC0; hdmi4_audio_config()
H A Dhdmi5_core.c865 audio_dma.block_size = 0xC0; hdmi5_audio_config()
/linux-4.1.27/drivers/staging/i2o/
H A Di2o_proc.c788 u16 block_size; i2o_seq_show_ddm_table() member in struct:__anon9812
890 u16 block_size; i2o_seq_show_drivers_stored() member in struct:__anon9813
967 u16 block_size; i2o_seq_show_groups() member in struct:__anon9814
1034 u16 block_size; i2o_seq_show_phys_device() member in struct:__anon9815
1075 u16 block_size; i2o_seq_show_claimed() member in struct:__anon9816
1123 u16 block_size; i2o_seq_show_users() member in struct:__anon9817
1175 u16 block_size; i2o_seq_show_priv_msgs() member in struct:__anon9818
1218 u16 block_size; i2o_seq_show_authorized_users() member in struct:__anon9819
/linux-4.1.27/arch/mips/include/asm/octeon/
H A Dcvmx-fpa.h275 * @block_size: Size for each block controlled by the FPA
282 uint64_t block_size, uint64_t num_blocks);
/linux-4.1.27/fs/hfsplus/
H A Dbtree.c74 u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size, hfsplus_calc_btree_clump_size() argument
77 u32 mod = max(node_size, block_size); hfsplus_calc_btree_clump_size()
H A Dhfsplus_fs.h392 u32 hfsplus_calc_btree_clump_size(u32 block_size, u32 node_size, u64 sectors,
/linux-4.1.27/sound/spi/
H A Dat73c213.c258 int block_size; snd_at73c213_pcm_prepare() local
260 block_size = frames_to_bytes(runtime, runtime->period_size); snd_at73c213_pcm_prepare()
269 (long)runtime->dma_addr + block_size); snd_at73c213_pcm_prepare()
363 int block_size; snd_at73c213_interrupt() local
369 block_size = frames_to_bytes(runtime, runtime->period_size); snd_at73c213_interrupt()
380 offset = block_size * next_period; snd_at73c213_interrupt()
/linux-4.1.27/arch/powerpc/mm/
H A Dhash_utils_64.c416 long unsigned int block_size; htab_dt_scan_hugepage_blocks() local
432 block_size = be64_to_cpu(addr_prop[1]); htab_dt_scan_hugepage_blocks()
433 if (block_size != (16 * GB)) htab_dt_scan_hugepage_blocks()
437 phys_addr, block_size, expected_pages); htab_dt_scan_hugepage_blocks()
439 memblock_reserve(phys_addr, block_size * expected_pages); htab_dt_scan_hugepage_blocks()
440 add_gpage(phys_addr, block_size, expected_pages); htab_dt_scan_hugepage_blocks()
/linux-4.1.27/drivers/net/wireless/
H A Dmwl8k.c653 int block_size = length > 256 ? 256 : length; mwl8k_load_fw_image() local
655 memcpy(cmd->payload, data + done, block_size); mwl8k_load_fw_image()
656 cmd->length = cpu_to_le16(block_size); mwl8k_load_fw_image()
659 sizeof(*cmd) + block_size); mwl8k_load_fw_image()
663 done += block_size; mwl8k_load_fw_image()
664 length -= block_size; mwl8k_load_fw_image()
692 u32 block_size; mwl8k_feed_fw_image() local
694 block_size = ioread32(priv->regs + MWL8K_HIU_SCRATCH); mwl8k_feed_fw_image()
695 if (block_size & 1) { mwl8k_feed_fw_image()
696 block_size &= ~1; mwl8k_feed_fw_image()
703 if (block_size > 1024 || block_size > length) { mwl8k_feed_fw_image()
713 if (block_size == 0) { mwl8k_feed_fw_image()
720 prev_block_size = block_size; mwl8k_feed_fw_image()
721 memcpy(buffer, data + done, block_size); mwl8k_feed_fw_image()
723 rc = mwl8k_send_fw_load_cmd(priv, buffer, block_size); mwl8k_feed_fw_image()
/linux-4.1.27/drivers/net/wireless/p54/
H A Dp54usb.c504 unsigned int left, remains, block_size; p54u_upload_firmware_3887() local
516 left = block_size = min_t(size_t, P54U_FW_BLOCK, priv->fw->size); p54u_upload_firmware_3887()
558 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size); p54u_upload_firmware_3887()
566 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains); p54u_upload_firmware_3887()
/linux-4.1.27/arch/s390/include/uapi/asm/
H A Dvtoc.h193 __u32 block_size; /* Disk block size */ member in struct:vtoc_cms_label
/linux-4.1.27/fs/ext4/
H A Dreadpage.c13 * should only be hit when page_size != block_size.
H A Dext4_extents.h63 * block_size % 12 >= 4 for at least all powers of 2 greater than 512, which
/linux-4.1.27/drivers/net/irda/
H A Dirda-usb.c1023 unsigned int block_size = 0; stir421x_fw_upload() local
1031 for (i = 0; i < patch_len; i += block_size) { stir421x_fw_upload()
1032 block_size = patch_len - i; stir421x_fw_upload()
1034 if (block_size > STIR421X_PATCH_BLOCK_SIZE) stir421x_fw_upload()
1035 block_size = STIR421X_PATCH_BLOCK_SIZE; stir421x_fw_upload()
1038 memcpy(patch_block, patch + i, block_size); stir421x_fw_upload()
1043 patch_block, block_size, stir421x_fw_upload()
/linux-4.1.27/fs/ecryptfs/
H A Dkeystore.c595 size_t block_size; member in struct:ecryptfs_write_tag_70_packet_silly_stack
661 s->block_size = crypto_blkcipher_blocksize(s->desc.tfm); ecryptfs_write_tag_70_packet()
666 if ((s->block_aligned_filename_size % s->block_size) != 0) { ecryptfs_write_tag_70_packet()
667 s->num_rand_bytes += (s->block_size ecryptfs_write_tag_70_packet()
669 % s->block_size)); ecryptfs_write_tag_70_packet()
884 size_t block_size; member in struct:ecryptfs_parse_tag_70_packet_silly_stack
/linux-4.1.27/virt/kvm/arm/
H A Dvgic.c1911 phys_addr_t *addr_ptr, block_size; kvm_vgic_addr() local
1919 block_size = KVM_VGIC_V2_DIST_SIZE; kvm_vgic_addr()
1925 block_size = KVM_VGIC_V2_CPU_SIZE; kvm_vgic_addr()
1932 block_size = KVM_VGIC_V3_DIST_SIZE; kvm_vgic_addr()
1938 block_size = KVM_VGIC_V3_REDIST_SIZE; kvm_vgic_addr()
1957 block_size); kvm_vgic_addr()
/linux-4.1.27/drivers/iommu/
H A Dio-pgtable-arm.c253 size_t block_size = ARM_LPAE_BLOCK_SIZE(lvl, data); __arm_lpae_map() local
259 if (size == block_size && (size & data->iop.cfg.pgsize_bitmap)) __arm_lpae_map()
/linux-4.1.27/drivers/infiniband/hw/mlx5/
H A Dqp.c2142 static u8 bs_selector(int block_size) bs_selector() argument
2144 switch (block_size) { bs_selector()
2290 u16 block_size = sig_attrs->mem.sig.dif.pi_interval; set_sig_data_segment() local
2299 pr_err("Bad block size given: %u\n", block_size); set_sig_data_segment()
2302 sblock_ctrl->bcount_per_cycle = cpu_to_be32(block_size + set_sig_data_segment()
2305 sblock_ctrl->repeat_count = cpu_to_be32(data_len / block_size); set_sig_data_segment()
2308 data_sentry->bcount = cpu_to_be16(block_size); set_sig_data_segment()
2311 data_sentry->stride = cpu_to_be16(block_size); set_sig_data_segment()
/linux-4.1.27/arch/arm/mach-omap2/
H A Dcontrol.c86 u32 block_size; member in struct:omap3_scratchpad_sdrc_block
407 sdrc_block_contents.block_size = 0x0; omap3_save_scratchpad_contents()
/linux-4.1.27/drivers/mtd/nand/gpmi-nand/
H A Dgpmi-lib.c254 unsigned int block_size; bch_set_geometry() local
265 block_size = bch_geo->ecc_chunk_size; bch_set_geometry()
292 | BF_BCH_FLASH0LAYOUT0_DATA0_SIZE(block_size, this), bch_set_geometry()
298 | BF_BCH_FLASH0LAYOUT1_DATAN_SIZE(block_size, this), bch_set_geometry()
/linux-4.1.27/block/
H A Dioctl.c363 return put_int(arg, block_size(bdev)); blkdev_ioctl()
H A Dcompat_ioctl.c717 return compat_put_int(arg, block_size(bdev)); compat_blkdev_ioctl()
/linux-4.1.27/drivers/gpu/drm/nouveau/
H A Dnouveau_ttm.c129 prefix, mm->block_size << 12); nouveau_vram_manager_debug()
H A Dnouveau_abi16.c130 if (chan->heap.block_size) nouveau_abi16_chan_fini()
/linux-4.1.27/arch/arm/mm/
H A Dcache-l2x0.c939 u32 block_size = 0; l2x0_cache_size_of_parse() local
944 of_property_read_u32(np, "cache-block-size", &block_size); l2x0_cache_size_of_parse()
952 if (block_size) { l2x0_cache_size_of_parse()
954 line_size = block_size; l2x0_cache_size_of_parse()
/linux-4.1.27/fs/xfs/
H A Dxfs_buf.h390 #define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev)
/linux-4.1.27/drivers/net/ethernet/sfc/
H A Dnic.h215 * @block_size: Write block size (in bytes).
225 unsigned int block_size; member in struct:falcon_spi_device
H A Dfalcon.c646 (spi->block_size - (start & (spi->block_size - 1)))); falcon_spi_write_limit()
2152 spi_device->block_size = falcon_spi_device_init()
/linux-4.1.27/drivers/media/dvb-frontends/
H A Ddrxk_hard.c440 const int block_size, const u8 p_block[]) write_block()
442 int status = 0, blk_size = block_size; write_block()
1327 u16 block_size; download_microcode() local
1351 block_size = ((p_src[0] << 8) | p_src[1]) * sizeof(u16); download_microcode()
1369 if (offset + block_size > length) { download_microcode()
1374 status = write_block(state, address, block_size, p_src); download_microcode()
1379 p_src += block_size; download_microcode()
1380 offset += block_size; download_microcode()
439 write_block(struct drxk_state *state, u32 address, const int block_size, const u8 p_block[]) write_block() argument
/linux-4.1.27/drivers/net/wireless/ath/ath6kl/
H A Dhtc_mbox.c2787 u32 block_size, ctrl_bufsz; ath6kl_htc_reset() local
2793 block_size = target->dev->ar->mbox_info.block_size; ath6kl_htc_reset()
2795 ctrl_bufsz = (block_size > HTC_MAX_CTRL_MSG_LEN) ? ath6kl_htc_reset()
2796 (block_size + HTC_HDR_LENGTH) : ath6kl_htc_reset()
H A Dcore.h522 u32 block_size; member in struct:ath6kl_mbox_info
H A Dhif.c683 dev->htc_cnxt->block_sz = dev->ar->mbox_info.block_size; ath6kl_hif_setup()
H A Dsdio.c102 mbox_info->block_size = HIF_MBOX_BLOCK_SIZE; ath6kl_sdio_set_mbox_info()
H A Dusb.c1142 ar->mbox_info.block_size = 16; ath6kl_usb_probe()
/linux-4.1.27/drivers/staging/rts5208/
H A Dms.c2161 u16 i, reg_addr, block_size; reset_ms() local
2308 block_size = ((u16)ptr[6] << 8) | ptr[7]; reset_ms()
2309 if (block_size == 0x0010) { reset_ms()
2313 } else if (block_size == 0x0008) { reset_ms()
/linux-4.1.27/drivers/infiniband/ulp/isert/
H A Dib_isert.c1865 u32 block_size = se_cmd->se_dev->dev_attrib.block_size + 8; isert_check_pi_status() local
1879 do_div(sec_offset_err, block_size); isert_check_pi_status()
2660 domain->sig.dif.pi_interval = se_cmd->se_dev->dev_attrib.block_size; isert_set_dif_domain()
/linux-4.1.27/drivers/net/ethernet/neterion/vxge/
H A Dvxge-config.c1154 blockpool->block_size = VXGE_HW_BLOCK_SIZE; __vxge_hw_blockpool_create()
2365 if (size != blockpool->block_size) { __vxge_hw_blockpool_malloc()
2461 if (size != blockpool->block_size) { __vxge_hw_blockpool_free()
4778 if (size == blockpool->block_size) { __vxge_hw_blockpool_block_allocate()
4960 if (entry->length == blockpool->block_size) { __vxge_hw_blockpool_block_free()
/linux-4.1.27/drivers/scsi/qla2xxx/
H A Dtcm_qla2xxx.c501 cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size; tcm_qla2xxx_write_pending()
680 cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size; tcm_qla2xxx_queue_data_in()
/linux-4.1.27/drivers/scsi/mpt2sas/
H A Dmpt2sas_base.h388 * @block_size: Block size of the volume
/linux-4.1.27/drivers/scsi/qla4xxx/
H A Dql4_fw.h312 uint32_t block_size; member in struct:qla_fdt_layout
/linux-4.1.27/drivers/net/wireless/mwifiex/
H A Dfw.h1250 __le16 block_size; member in struct:host_cmd_sdio_sp_rx_aggr_cfg
H A Dsta_cmdresp.c959 adapter->sdio_rx_block_size = le16_to_cpu(cfg->block_size); mwifiex_ret_sdio_rx_aggr_cfg()

Completed in 5309 milliseconds

12