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

12

/linux-4.4.14/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:__anon11349
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.c377 inode->i_blocks = befs_sb->block_size / VFS_BLOCK_SIZE; befs_iget()
388 num_blks * (befs_sb->block_size / VFS_BLOCK_SIZE); befs_iget()
833 sb_set_blocksize(sb, (ulong) befs_sb->block_size); befs_fill_super()
/linux-4.4.14/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 Dsclp_cmd.c408 unsigned long long start, size, addr, block_size; add_memory_merged() local
427 block_size = memory_block_size_bytes(); add_memory_merged()
428 align_to_block_size(&start, &size, block_size); add_memory_merged()
431 for (addr = start; addr < start + size; addr += block_size) add_memory_merged()
432 add_memory(numa_pfn_to_nid(PFN_DOWN(addr)), addr, block_size); add_memory_merged()
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.4.14/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()
167 unsigned int block_size = ccp_sha_init() local
177 memcpy(rctx->buf, ctx->u.sha.ipad, block_size); ccp_sha_init()
178 rctx->buf_count = block_size; ccp_sha_init()
258 unsigned int block_size = crypto_shash_blocksize(shash); ccp_sha_setkey() local
270 if (key_len > block_size) { ccp_sha_setkey()
288 for (i = 0; i < block_size; i++) { ccp_sha_setkey()
293 sg_init_one(&ctx->u.sha.opad_sg, ctx->u.sha.opad, block_size); ccp_sha_setkey()
294 ctx->u.sha.opad_count = block_size; ccp_sha_setkey()
351 u32 block_size; member in struct:ccp_sha_def
360 .block_size = SHA1_BLOCK_SIZE,
367 .block_size = SHA224_BLOCK_SIZE,
374 .block_size = SHA256_BLOCK_SIZE,
460 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()
136 int pad_length = block_size - (len & (block_size - 1)); ccp_do_cmac_update()
H A Dccp-ops.c751 struct ccp_op *op, unsigned int block_size, ccp_prepare_data()
772 /* The data operation length will be at least block_size in length ccp_prepare_data()
776 op_len = max(op_len, block_size); ccp_prepare_data()
781 if (sg_src_len < block_size) { ccp_prepare_data()
790 op->src.u.dma.length = (blocksize_op) ? block_size : cp_len; ccp_prepare_data()
797 op->src.u.dma.length = op_len & ~(block_size - 1); ccp_prepare_data()
803 if (sg_dst_len < block_size) { ccp_prepare_data()
1504 u64 block_size, digest_size; ccp_run_sha_cmd() local
1509 block_size = SHA1_BLOCK_SIZE; ccp_run_sha_cmd()
1513 block_size = SHA224_BLOCK_SIZE; ccp_run_sha_cmd()
1517 block_size = SHA256_BLOCK_SIZE; ccp_run_sha_cmd()
1525 if (sha->opad_len != block_size) { ccp_run_sha_cmd()
1530 hmac_buf = kmalloc(block_size + digest_size, GFP_KERNEL); ccp_run_sha_cmd()
1535 sg_init_one(&sg, hmac_buf, block_size + digest_size); ccp_run_sha_cmd()
1537 scatterwalk_map_and_copy(hmac_buf, sha->opad, 0, block_size, 0); ccp_run_sha_cmd()
1538 memcpy(hmac_buf + block_size, ctx.address, digest_size); ccp_run_sha_cmd()
1546 hmac_cmd.u.sha.src_len = block_size + digest_size; ccp_run_sha_cmd()
1551 hmac_cmd.u.sha.msg_bits = (block_size + digest_size) << 3; ccp_run_sha_cmd()
750 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.4.14/drivers/staging/wilc1000/
H A Dwilc_sdio.c18 u32 block_size; member in struct:__anon10876
78 static int sdio_set_func0_block_size(u32 block_size) sdio_set_func0_block_size() argument
86 cmd.data = (u8)block_size; sdio_set_func0_block_size()
93 cmd.data = (u8)(block_size >> 8); sdio_set_func0_block_size()
110 static int sdio_set_func1_block_size(u32 block_size) sdio_set_func1_block_size() argument
118 cmd.data = (u8)block_size; sdio_set_func1_block_size()
124 cmd.data = (u8)(block_size >> 8); sdio_set_func1_block_size()
258 cmd.block_size = g_sdio.block_size; /* johnny : prevent it from setting unexpected value */ sdio_write_reg()
275 u32 block_size = g_sdio.block_size; sdio_write() local
310 nblk = size / block_size; sdio_write()
311 nleft = size % block_size; sdio_write()
318 cmd.block_size = block_size; sdio_write()
328 addr += nblk * block_size; sdio_write()
329 buf += nblk * block_size; sdio_write()
338 cmd.block_size = block_size; /* johnny : prevent it from setting unexpected value */ sdio_write()
385 cmd.block_size = g_sdio.block_size; /* johnny : prevent it from setting unexpected value */ sdio_read_reg()
406 u32 block_size = g_sdio.block_size; sdio_read() local
441 nblk = size / block_size; sdio_read()
442 nleft = size % block_size; sdio_read()
449 cmd.block_size = block_size; sdio_read()
459 addr += nblk * block_size; sdio_read()
460 buf += nblk * block_size; sdio_read()
469 cmd.block_size = block_size; /* johnny : prevent it from setting unexpected value */ sdio_read()
602 g_sdio.block_size = WILC_SDIO_BLOCK_SIZE; sdio_init()
H A Dlinux_wlan_sdio.c96 func->cur_blksize = cmd->block_size; linux_sdio_cmd53()
98 size = cmd->count * cmd->block_size; linux_sdio_cmd53()
H A Dwilc_wlan_if.h71 u32 block_size; member in struct:__anon10892
/linux-4.4.14/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.4.14/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.4.14/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.c114 static uint32_t calc_max_entries(size_t value_size, size_t block_size) calc_max_entries() argument
119 block_size -= sizeof(struct node_header); calc_max_entries()
120 total = block_size / elt_size; calc_max_entries()
131 size_t block_size; dm_btree_empty() local
138 block_size = dm_bm_block_size(dm_tm_get_bm(info->tm)); dm_btree_empty()
139 max_entries = calc_max_entries(info->value_type.size, block_size); dm_btree_empty()
142 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.4.14/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.4.14/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.h45 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.4.14/drivers/target/
H A Dtarget_core_sbc.c77 buf[4] = (dev->dev_attrib.block_size >> 24) & 0xff; sbc_emulate_readcapacity()
78 buf[5] = (dev->dev_attrib.block_size >> 16) & 0xff; sbc_emulate_readcapacity()
79 buf[6] = (dev->dev_attrib.block_size >> 8) & 0xff; sbc_emulate_readcapacity()
80 buf[7] = dev->dev_attrib.block_size & 0xff; sbc_emulate_readcapacity()
112 buf[8] = (dev->dev_attrib.block_size >> 24) & 0xff; sbc_emulate_readcapacity_16()
113 buf[9] = (dev->dev_attrib.block_size >> 16) & 0xff; sbc_emulate_readcapacity_16()
114 buf[10] = (dev->dev_attrib.block_size >> 8) & 0xff; sbc_emulate_readcapacity_16()
115 buf[11] = dev->dev_attrib.block_size & 0xff; sbc_emulate_readcapacity_16()
238 return cmd->se_dev->dev_attrib.block_size * sectors; sbc_get_size()
476 unsigned int block_size = dev->dev_attrib.block_size; compare_and_write_callback() local
477 unsigned int compare_len = (nlbas * block_size); compare_and_write_callback()
554 len = cmd->t_task_nolb * block_size; compare_and_write_callback()
562 if (block_size < PAGE_SIZE) { compare_and_write_callback()
563 sg_set_page(&write_sg[i], m.page, block_size, compare_and_write_callback()
564 m.piter.sg->offset + block_size); compare_and_write_callback()
567 sg_set_page(&write_sg[i], m.page, block_size, compare_and_write_callback()
570 len -= block_size; compare_and_write_callback()
634 * Reset cmd->data_length to individual block_size in order to not sbc_compare_and_write()
638 cmd->data_length = cmd->t_task_nolb * dev->dev_attrib.block_size; sbc_compare_and_write()
785 cmd->data_length = sectors * dev->dev_attrib.block_size; sbc_check_prot()
1243 unsigned int block_size = dev->dev_attrib.block_size; sbc_dif_generate() local
1266 avail = min(block_size, dsg->length - offset); sbc_dif_generate()
1268 if (avail < block_size) { sbc_dif_generate()
1276 offset = block_size - avail; sbc_dif_generate()
1279 offset += block_size; sbc_dif_generate()
1400 unsigned int block_size = dev->dev_attrib.block_size; sbc_dif_verify() local
1431 dsg_off += block_size; sbc_dif_verify()
1435 avail = min(block_size, dsg->length - dsg_off); sbc_dif_verify()
1437 if (avail < block_size) { sbc_dif_verify()
1445 dsg_off = block_size - avail; sbc_dif_verify()
1448 dsg_off += block_size; sbc_dif_verify()
H A Dtarget_core_file.c250 u32 block_size, struct scatterlist *sgl, fd_do_rw()
257 loff_t pos = (cmd->t_task_lba * block_size); fd_do_rw()
334 start = cmd->t_task_lba * dev->dev_attrib.block_size; fd_execute_sync_cache()
361 loff_t pos = cmd->t_task_lba * se_dev->dev_attrib.block_size; fd_execute_write_same()
379 cmd->t_data_sg[0].length != cmd->se_dev->dev_attrib.block_size) { fd_execute_write_same()
381 " block_size: %u\n", fd_execute_write_same()
384 cmd->se_dev->dev_attrib.block_size); fd_execute_write_same()
397 len += se_dev->dev_attrib.block_size; fd_execute_write_same()
493 loff_t pos = lba * se_dev->dev_attrib.block_size; fd_execute_unmap()
494 unsigned int len = nolb * se_dev->dev_attrib.block_size; fd_execute_unmap()
543 ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size, fd_execute_rw()
548 ilog2(dev->dev_attrib.block_size); fd_execute_rw()
558 ilog2(dev->dev_attrib.block_size); fd_execute_rw()
566 ret = fd_do_rw(cmd, file, dev->dev_attrib.block_size, fd_execute_rw()
575 dev->dev_attrib.block_size; fd_execute_rw()
715 return div_u64(dev_size - dev->dev_attrib.block_size, fd_get_blocks()
716 dev->dev_attrib.block_size); fd_get_blocks()
759 int unit_size = FDBD_FORMAT_UNIT_SIZE * dev->dev_attrib.block_size; fd_format_prot()
249 fd_do_rw(struct se_cmd *cmd, struct file *fd, u32 block_size, struct scatterlist *sgl, u32 sgl_nents, u32 data_length, int is_write) fd_do_rw() argument
H A Dtarget_core_iblock.c206 u32 block_size = bdev_logical_block_size(bd); iblock_emulate_read_cap_with_block_size() local
208 if (block_size == dev->dev_attrib.block_size) iblock_emulate_read_cap_with_block_size()
211 switch (block_size) { iblock_emulate_read_cap_with_block_size()
213 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
227 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
242 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
257 switch (dev->dev_attrib.block_size) { iblock_emulate_read_cap_with_block_size()
435 sg->length != cmd->se_dev->dev_attrib.block_size) { iblock_execute_write_same()
437 " block_size: %u\n", cmd->t_data_nents, sg->length, iblock_execute_write_same()
438 cmd->se_dev->dev_attrib.block_size); iblock_execute_write_same()
611 bip->bip_iter.bi_size = (cmd->data_length / dev->dev_attrib.block_size) * iblock_alloc_bip()
H A Dtarget_core_rd.c253 static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block_size) rd_build_prot_space() argument
265 * tot sg needed = rd_page_count * (PGSZ/block_size) * rd_build_prot_space()
266 * (prot_length/block_size) + pad rd_build_prot_space()
269 total_sg_needed = (rd_dev->rd_page_count * prot_length / block_size) + 1; rd_build_prot_space()
408 u32 sectors = cmd->data_length / se_dev->dev_attrib.block_size; rd_do_prot_rw()
462 tmp = cmd->t_task_lba * se_dev->dev_attrib.block_size; rd_execute_rw()
629 dev->dev_attrib.block_size) - 1; rd_get_blocks()
642 dev->dev_attrib.block_size); rd_init_prot()
H A Dtarget_core_spc.c513 put_unaligned_be16(min / dev->dev_attrib.block_size, &buf[6]); spc_emulate_evpd_b0()
525 dev->dev_attrib.block_size; spc_emulate_evpd_b0()
533 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()
1020 u32 block_size = dev->dev_attrib.block_size; spc_emulate_modesense() local
1025 blocks, block_size); spc_emulate_modesense()
1029 blocks, block_size); spc_emulate_modesense()
1033 block_size); spc_emulate_modesense()
H A Dtarget_core_xcopy.c629 u32 length = (src_sectors * src_dev->dev_attrib.block_size); target_xcopy_read_source()
689 u32 length = (dst_sectors * dst_dev->dev_attrib.block_size); target_xcopy_write_destination()
809 copied_nolb, copied_nolb * dst_dev->dev_attrib.block_size); target_xcopy_do_work()
882 if (xop->src_dev->dev_attrib.block_size != target_do_xcopy()
883 xop->dst_dev->dev_attrib.block_size) { target_do_xcopy()
884 pr_err("XCOPY: Non matching src_dev block_size: %u + dst_dev" target_do_xcopy()
885 " block_size: %u currently unsupported\n", target_do_xcopy()
886 xop->src_dev->dev_attrib.block_size, target_do_xcopy()
887 xop->dst_dev->dev_attrib.block_size); target_do_xcopy()
H A Dtarget_core_device.c536 static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size) se_dev_align_max_sectors() argument
544 alignment = max(1ul, PAGE_SIZE / block_size); se_dev_align_max_sectors()
835 struct request_queue *q, int block_size) target_configure_unmap_from_queue()
841 block_size; target_configure_unmap_from_queue()
846 attrib->unmap_granularity = q->limits.discard_granularity / block_size; target_configure_unmap_from_queue()
848 block_size; target_configure_unmap_from_queue()
859 switch (dev->dev_attrib.block_size) { target_to_linux_sector()
889 dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size; target_configure_device()
834 target_configure_unmap_from_queue(struct se_dev_attrib *attrib, struct request_queue *q, int block_size) target_configure_unmap_from_queue() argument
H A Dtarget_core_transport.c816 dev->dev_attrib.block_size, transport_dump_dev_state()
1119 u32 sectors = (mtl / dev->dev_attrib.block_size); target_check_max_data_sg_nents()
1148 if (dev->dev_attrib.block_size != 512) { target_cmd_size_check()
1785 sectors = cmd->data_length >> ilog2(cmd->se_dev->dev_attrib.block_size); target_write_prot_action()
2010 ilog2(cmd->se_dev->dev_attrib.block_size); target_read_prot_action()
2356 cmd->se_dev->dev_attrib.block_size; transport_generic_new_cmd()
2378 cmd->se_dev->dev_attrib.block_size; transport_generic_new_cmd()
H A Dtarget_core_user.c1081 return div_u64(udev->dev_size - dev->dev_attrib.block_size, tcmu_get_blocks()
1082 dev->dev_attrib.block_size); tcmu_get_blocks()
H A Dtarget_core_configfs.c493 DEF_CONFIGFS_ATTRIB_SHOW(block_size); variable
951 pr_err("dev[%p]: Unable to change SE Device block_size" block_size_store()
964 da->block_size = val; block_size_store()
968 pr_debug("dev[%p]: SE Device block_size changed to %u\n", block_size_store()
992 CONFIGFS_ATTR(, block_size);
/linux-4.4.14/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()
/linux-4.4.14/include/linux/platform_data/
H A Ddma-dw.h43 * @block_size: Maximum block size supported by the controller
58 unsigned short block_size; member in struct:dw_dma_platform_data
/linux-4.4.14/drivers/staging/comedi/
H A Dcomedi_buf.c314 int block_size = num_bytes - count; comedi_buf_munge() local
318 if (block_size > buf_end) comedi_buf_munge()
319 block_size = buf_end; comedi_buf_munge()
323 block_size, async->munge_chan); comedi_buf_munge()
331 async->munge_chan += block_size / num_sample_bytes; comedi_buf_munge()
333 async->munge_count += block_size; comedi_buf_munge()
334 async->munge_ptr += block_size; comedi_buf_munge()
336 count += block_size; comedi_buf_munge()
500 unsigned int block_size; comedi_buf_memcpy_to() local
503 block_size = async->prealloc_bufsz - write_ptr; comedi_buf_memcpy_to()
505 block_size = num_bytes; comedi_buf_memcpy_to()
507 memcpy(async->prealloc_buf + write_ptr, data, block_size); comedi_buf_memcpy_to()
509 data += block_size; comedi_buf_memcpy_to()
510 num_bytes -= block_size; comedi_buf_memcpy_to()
524 unsigned int block_size; comedi_buf_memcpy_from() local
529 block_size = async->prealloc_bufsz - read_ptr; comedi_buf_memcpy_from()
531 block_size = nbytes; comedi_buf_memcpy_from()
533 memcpy(dest, src, block_size); comedi_buf_memcpy_from()
534 nbytes -= block_size; comedi_buf_memcpy_from()
535 dest += block_size; comedi_buf_memcpy_from()
/linux-4.4.14/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.4.14/drivers/gpu/drm/nouveau/include/nvkm/core/
H A Dmm.h23 u32 block_size; member in struct:nvkm_mm
/linux-4.4.14/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.4.14/drivers/gpu/drm/vmwgfx/device_include/
H A Dsvga3d_surfacedefs.h205 surf_size_struct block_size; member in struct:svga3d_surface_desc
988 surf_size_struct *block_size) svga3dsurface_get_size_in_blocks()
990 block_size->width = DIV_ROUND_UP(pixel_size->width, svga3dsurface_get_size_in_blocks()
991 desc->block_size.width); svga3dsurface_get_size_in_blocks()
992 block_size->height = DIV_ROUND_UP(pixel_size->height, svga3dsurface_get_size_in_blocks()
993 desc->block_size.height); svga3dsurface_get_size_in_blocks()
994 block_size->depth = DIV_ROUND_UP(pixel_size->depth, svga3dsurface_get_size_in_blocks()
995 desc->block_size.depth); svga3dsurface_get_size_in_blocks()
1101 const u32 bw = desc->block_size.width, bh = desc->block_size.height; svga3dsurface_get_pixel_offset()
1102 const u32 bd = desc->block_size.depth; svga3dsurface_get_pixel_offset()
986 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.4.14/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.4.14/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.4.14/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.c1413 d->block_size = le32_to_cpu(d->block_size); esas2r_nuxi_mgt_data()
1441 g->block_size = le32_to_cpu(g->block_size); esas2r_nuxi_mgt_data()
1461 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.4.14/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.4.14/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()
565 .count = b->c->block_size >> SECTOR_SHIFT, use_dmio()
623 len = b->c->block_size; use_inline_bio()
634 BUG_ON(b->c->block_size <= PAGE_SIZE); use_inline_bio()
652 if (b->c->block_size <= DM_BUFIO_INLINE_VECS * PAGE_SIZE && submit_io()
1426 return c->block_size; dm_bufio_get_block_size()
1519 return retain_bytes / c->block_size; get_retain_buffers()
1580 struct dm_bufio_client *dm_bufio_client_create(struct block_device *bdev, unsigned block_size, dm_bufio_client_create() argument
1589 BUG_ON(block_size < 1 << SECTOR_SHIFT || dm_bufio_client_create()
1590 (block_size & (block_size - 1))); dm_bufio_client_create()
1600 c->block_size = block_size; dm_bufio_client_create()
1601 c->sectors_per_block_bits = __ffs(block_size) - SECTOR_SHIFT; dm_bufio_client_create()
1602 c->pages_per_block_bits = (__ffs(block_size) >= PAGE_SHIFT) ? dm_bufio_client_create()
1603 __ffs(block_size) - PAGE_SHIFT : 0; dm_bufio_client_create()
1604 c->blocks_per_page_bits = (__ffs(block_size) < PAGE_SHIFT ? dm_bufio_client_create()
1605 PAGE_SHIFT - __ffs(block_size) : 0); dm_bufio_client_create()
1634 DM_BUFIO_CACHE_NAME(c) = kasprintf(GFP_KERNEL, "dm_bufio_cache-%u", c->block_size); dm_bufio_client_create()
1644 c->block_size, dm_bufio_client_create()
1645 c->block_size, 0, NULL); dm_bufio_client_create()
H A Ddm-era-target.c266 dm_block_t block_size; member in struct:era_metadata
500 disk->data_block_size = cpu_to_le32(md->block_size); prepare_superblock()
534 * Assumes block_size and the infos are set.
578 md->block_size = le32_to_cpu(disk->data_block_size); open_metadata()
779 sector_t block_size, metadata_open()
789 md->block_size = block_size; metadata_open()
1413 static bool valid_block_size(dm_block_t block_size) valid_block_size() argument
1415 bool greater_than_zero = block_size > 0; valid_block_size()
1416 bool multiple_of_min_block_size = (block_size & (MIN_BLOCK_SIZE - 1)) == 0; valid_block_size()
778 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-policy-internal.h143 sector_t origin_size, sector_t block_size);
H A Ddm-cache-target.c2413 uint32_t block_size; member in struct:cache_args
2517 unsigned long block_size; parse_block_size() local
2522 if (kstrtoul(dm_shift_arg(as), 10, &block_size) || !block_size || parse_block_size()
2523 block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS || parse_block_size()
2524 block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS || parse_block_size()
2525 block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) { parse_block_size()
2530 if (block_size > ca->cache_sectors) { parse_block_size()
2535 ca->block_size = block_size; parse_block_size()
2795 origin_blocks = block_div(origin_blocks, ca->block_size); cache_create()
2798 cache->sectors_per_block = ca->block_size; cache_create()
2804 if (ca->block_size & (ca->block_size - 1)) { cache_create()
2808 cache_size = block_div(cache_size, ca->block_size); cache_create()
2811 cache->sectors_per_block_shift = __ffs(ca->block_size); cache_create()
2829 ca->block_size, may_format, cache_create()
3314 dm_block_t block_size; member in struct:discard_load_info
3335 b = li->discard_begin * li->block_size; set_discard_range()
3336 e = li->discard_end * li->block_size; set_discard_range()
3360 li->block_size = discard_block_size; load_discard()
H A Ddm-thin-metadata.c225 size_t block_size) sb_prepare_for_write()
231 block_size - sizeof(__le32), sb_prepare_for_write()
237 size_t block_size) sb_check()
257 block_size - sizeof(__le32), sb_check()
381 unsigned block_size = dm_bm_block_size(bm) / sizeof(__le64); __superblock_all_zeroes() local
392 for (i = 0; i < block_size; i++) { __superblock_all_zeroes()
223 sb_prepare_for_write(struct dm_block_validator *v, struct dm_block *b, size_t block_size) sb_prepare_for_write() argument
235 sb_check(struct dm_block_validator *v, struct dm_block *b, size_t block_size) sb_check() argument
H A Ddm-thin.c2665 static bool is_factor(sector_t block_size, uint32_t n) is_factor() argument
2667 return !sector_div(block_size, n); is_factor()
2768 unsigned long block_size, pool_create()
2777 pmd = dm_pool_metadata_open(metadata_dev, block_size, format_device); pool_create()
2791 pool->sectors_per_block = block_size; pool_create()
2792 if (block_size & (block_size - 1)) pool_create()
2795 pool->sectors_per_block_shift = __ffs(block_size); pool_create()
2911 unsigned long block_size, int read_only, __pool_find()
2933 pool = pool_create(pool_md, metadata_dev, block_size, read_only, error); __pool_find()
3091 unsigned long block_size; pool_ctr() local
3134 if (kstrtoul(argv[2], 10, &block_size) || !block_size || pool_ctr()
3135 block_size < DATA_DEV_BLOCK_SIZE_MIN_SECTORS || pool_ctr()
3136 block_size > DATA_DEV_BLOCK_SIZE_MAX_SECTORS || pool_ctr()
3137 block_size & (DATA_DEV_BLOCK_SIZE_MIN_SECTORS - 1)) { pool_ctr()
3156 block_size, pf.mode == PM_READ_ONLY, &ti->error, &pool_created); pool_ctr()
2766 pool_create(struct mapped_device *pool_md, struct block_device *metadata_dev, unsigned long block_size, int read_only, char **error) pool_create() argument
2909 __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.h257 sector_t block_size);
/linux-4.4.14/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.c286 blk_size = card->config.data.block_size; rsxx_setup_dev()
/linux-4.4.14/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.4.14/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.4.14/drivers/scsi/
H A Dst.c692 if (STp->block_size == 0) write_behind_check()
695 STps->drv_block += STbuffer->writing / STp->block_size; write_behind_check()
783 blks = transfer / STp->block_size; st_flush_write_buffer()
850 if (STp->block_size == 0) flush_buffer()
854 (STp->buffer)->read_pointer) / STp->block_size - flush_buffer()
855 ((STp->buffer)->read_pointer + STp->block_size - 1) / flush_buffer()
856 STp->block_size; flush_buffer()
900 STm->default_blksize != STp->block_size) { set_mode_densblk()
904 arg |= STp->block_size; set_mode_densblk()
1101 STp->block_size = 0; check_tape()
1152 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */ check_tape()
1166 STp->block_size = (STp->buffer)->b_data[9] * 65536 + check_tape()
1188 if (STp->block_size > 0) check_tape()
1190 (STp->buffer)->buffer_size / STp->block_size; check_tape()
1196 STp->block_size, (STp->buffer)->buffer_size, check_tape()
1535 if (STp->block_size == 0 && STp->max_block > 0 && rw_checks()
1583 if (STp->block_size) setup_buffering()
1584 bufsize = STp->block_size > st_fixed_buffer_size ? setup_buffering()
1585 STp->block_size : st_fixed_buffer_size; setup_buffering()
1602 if (STp->block_size)
1603 STbp->buffer_blocks = bufsize / STp->block_size;
1650 if (STp->block_size != 0 && (count % STp->block_size) != 0) { st_write()
1709 if (STp->block_size != 0 && st_write()
1725 cmd[1] = (STp->block_size != 0); st_write()
1736 if (STp->block_size == 0) st_write()
1739 do_count = STbp->buffer_blocks * STp->block_size - st_write()
1754 async_write = STp->block_size == 0 && !STbp->do_dio && st_write()
1757 if (STp->block_size != 0 && STm->do_buffer_writes && st_write()
1767 if (STp->block_size == 0) st_write()
1774 blks /= STp->block_size; st_write()
1775 transfer = blks * STp->block_size; st_write()
1805 else if (STp->block_size == 0 && st_write()
1810 if (STp->block_size != 0) st_write()
1811 undone *= STp->block_size; st_write()
1817 if (STp->block_size) st_write()
1818 blks = (transfer - undone) / STp->block_size; st_write()
1824 if (STp->block_size == 0 || st_write()
1839 STp->block_size; st_write()
1869 if (STp->block_size == 0) st_write()
1927 if (STp->block_size == 0) read_tape()
1932 bytes = blks * STp->block_size; read_tape()
1937 blks = bytes / STp->block_size; read_tape()
1938 bytes = blks * STp->block_size; read_tape()
1944 cmd[1] = (STp->block_size != 0); read_tape()
1985 if (STp->block_size == 0 && read_tape()
1990 if (STp->block_size == 0 && read_tape()
2002 } else if (STp->block_size == 0) { read_tape()
2018 STp->block_size; read_tape()
2034 if (STp->block_size == 0) read_tape()
2038 bytes - transfer * STp->block_size; read_tape()
2047 if (STp->block_size == 0) read_tape()
2051 bytes - transfer * STp->block_size; read_tape()
2089 if (STp->block_size == 0)
2092 STps->drv_block += STbp->buffer_bytes / STp->block_size; st_read()
2121 if (STp->block_size != 0 && (count % STp->block_size) != 0) { st_read()
2208 if (STp->block_size == 0) st_read()
2941 ltmp = STp->block_size; st_int_ioctl()
2987 STp->block_size = arg & MT_ST_BLKSIZE_MASK; st_int_ioctl()
2988 if (STp->block_size != 0) { st_int_ioctl()
2990 (STp->buffer)->buffer_size / STp->block_size; st_int_ioctl()
3665 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) | st_ioctl()
3669 if (STp->block_size != 0) { st_ioctl()
3672 (STp->buffer)->buffer_bytes / STp->block_size; st_ioctl()
3676 STp->block_size - 1) / STp->block_size; st_ioctl()
3707 (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.h177 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.h703 __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:__anon9400
/linux-4.4.14/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
916 unsigned int block_size; sahara_sha_prepare_request() local
919 block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); sahara_sha_prepare_request()
925 if (!rctx->last && (len < block_size)) { sahara_sha_prepare_request()
938 /* data must always be a multiple of block_size */ sahara_sha_prepare_request()
939 hash_later = rctx->last ? 0 : len & (block_size - 1); sahara_sha_prepare_request()
/linux-4.4.14/drivers/md/bcache/
H A Dsuper.c116 sb->block_size = le16_to_cpu(s->block_size); read_super()
119 if (sb->block_size << 9 < bdev_logical_block_size(bdev)) read_super()
137 sb->block_size = le16_to_cpu(s->block_size); read_super()
152 if (!is_power_of_2(sb->block_size) || read_super()
153 sb->block_size > PAGE_SECTORS || read_super()
747 static int bcache_device_init(struct bcache_device *d, unsigned block_size, bcache_device_init() argument
812 q->limits.io_min = block_size; bcache_device_init()
813 q->limits.logical_block_size = block_size; bcache_device_init()
814 q->limits.physical_block_size = block_size; bcache_device_init()
954 if (dc->sb.block_size < c->sb.block_size) { bch_cached_dev_attach()
1092 static int cached_dev_init(struct cached_dev *dc, unsigned block_size) cached_dev_init() argument
1122 ret = bcache_device_init(&dc->disk, block_size, cached_dev_init()
1159 if (cached_dev_init(dc, sb->block_size << 9)) register_bdev()
1475 c->sb.block_size = sb->block_size; bch_cache_set_alloc()
1480 c->block_bits = ilog2(sb->block_size); bch_cache_set_alloc()
1511 iter_size = (sb->bucket_size / sb->block_size + 1) * bch_cache_set_alloc()
1706 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;
695 block_bytes(c)) * c->sb.block_size; journal_wait_for_write()
698 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.h509 /* log2(block_size), in sectors */
692 #define block_bytes(c) ((c)->sb.block_size << 9)
H A Drequest.c389 if (bio->bi_iter.bi_sector & (c->sb.block_size - 1) || check_should_bypass()
390 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.4.14/drivers/s390/block/
H A Ddasd_diag.h59 u32 block_size; member in struct:dasd_diag_init_io
H A Ddasd_diag.c116 iib->block_size = blocksize; mdsk_init_io()
443 bsize = (unsigned int) label->block_size; dasd_diag_check_device()
/linux-4.4.14/drivers/gpu/drm/i915/
H A Dintel_bios.c79 u16 *block_ptr, block_size; get_blocksize() local
82 block_size = *block_ptr; get_blocksize()
83 return block_size; get_blocksize()
383 u16 block_size = get_blocksize(general); parse_general_definitions() local
384 if (block_size >= sizeof(*general)) { parse_general_definitions()
391 block_size); parse_general_definitions()
410 u16 block_size; parse_sdvo_device_mapping() local
428 block_size = get_blocksize(p_defs); parse_sdvo_device_mapping()
430 child_device_num = (block_size - sizeof(*p_defs)) / parse_sdvo_device_mapping()
752 u16 block_size; parse_mipi() local
814 block_size = get_blocksize(sequence); parse_mipi()
835 if ((seq_data - &sequence->data[0]) > block_size) { parse_mipi()
848 if (seq_size > block_size) { parse_mipi()
1082 u16 block_size; parse_device_mapping() local
1115 block_size = get_blocksize(p_defs); parse_device_mapping()
1117 child_device_num = (block_size - sizeof(*p_defs)) / parse_device_mapping()
H A Dintel_bios.h290 * number = (block_size - sizeof(bdb_general_definitions))/
/linux-4.4.14/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.4.14/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.4.14/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.c562 cxt->ecc_info.ecc_size, cxt->ecc_info.block_size); ramoops_probe()
/linux-4.4.14/fs/ufs/
H A Dsuper.c758 unsigned block_size, super_block_size; ufs_fill_super() local
821 uspi->s_fsize = block_size = 512; ufs_fill_super()
831 uspi->s_fsize = block_size = 512; ufs_fill_super()
841 uspi->s_fsize = block_size = 1024; ufs_fill_super()
852 uspi->s_fsize = block_size = 1024; ufs_fill_super()
864 uspi->s_fsize = block_size = 1024; ufs_fill_super()
875 uspi->s_fsize = block_size = 1024; ufs_fill_super()
890 uspi->s_fsize = block_size = 1024; ufs_fill_super()
906 uspi->s_fsize = block_size = 2048; ufs_fill_super()
922 uspi->s_fsize = block_size = 1024; ufs_fill_super()
938 uspi->s_fsize = block_size = 1024; ufs_fill_super()
957 if (!sb_set_blocksize(sb, block_size)) { ufs_fill_super()
966 ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size); ufs_fill_super()
1060 if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) { ufs_fill_super()
1063 block_size = uspi->s_fsize; ufs_fill_super()
1065 UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size); ufs_fill_super()
/linux-4.4.14/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.4.14/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()
/linux-4.4.14/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()
260 .block_size = 4095,
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()
1632 dwc->block_size = dw_dma_probe()
1637 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.4.14/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.4.14/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.4.14/drivers/crypto/qat/qat_common/
H A Dqat_algs.c153 int block_size = crypto_shash_blocksize(ctx->hash_tfm); qat_alg_do_precomputes() local
155 char ipad[block_size]; qat_alg_do_precomputes()
156 char opad[block_size]; qat_alg_do_precomputes()
161 memset(ipad, 0, block_size); qat_alg_do_precomputes()
162 memset(opad, 0, block_size); qat_alg_do_precomputes()
166 if (auth_keylen > block_size) { qat_alg_do_precomputes()
178 for (i = 0; i < block_size; i++) { qat_alg_do_precomputes()
188 if (crypto_shash_update(shash, ipad, block_size)) qat_alg_do_precomputes()
220 if (crypto_shash_update(shash, opad, block_size)) qat_alg_do_precomputes()
249 memzero_explicit(ipad, block_size); qat_alg_do_precomputes()
250 memzero_explicit(opad, block_size); qat_alg_do_precomputes()
/linux-4.4.14/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.4.14/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
964 block_size = data->blksz; mmc_omap_prepare_data()
967 OMAP_MMC_WRITE(host, BLEN, block_size - 1); mmc_omap_prepare_data()
977 if ((sg->length % block_size) != 0) { mmc_omap_prepare_data()
1060 host->total_bytes_left = data->blocks * block_size; mmc_omap_prepare_data()
/linux-4.4.14/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.h920 u32 block_size; member in struct:fsa_dev_info
1704 __le32 block_size; member in struct:aac_blockdevinfo
/linux-4.4.14/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.4.14/include/target/
H A Dtarget_core_backend.h99 struct request_queue *q, int block_size);
H A Dtarget_core_base.h681 u32 block_size; member in struct:se_dev_attrib
/linux-4.4.14/drivers/block/
H A Dcciss.c179 sector_t *total_size, unsigned int *block_size);
181 sector_t *total_size, unsigned int *block_size);
184 unsigned int block_size, InquiryData_struct *inq_buff,
1975 h->drv[drv_index]->block_size); cciss_add_disk()
2007 unsigned int block_size; cciss_update_drive_info() local
2022 &total_size, &block_size); cciss_update_drive_info()
2025 cciss_read_capacity(h, drv_index, &total_size, &block_size); cciss_update_drive_info()
2031 &total_size, &block_size); cciss_update_drive_info()
2040 cciss_geometry_inquiry(h, drv_index, total_size, block_size, cciss_update_drive_info()
2042 drvinfo->block_size = block_size; cciss_update_drive_info()
2057 drvinfo->block_size == h->drv[drv_index]->block_size && cciss_update_drive_info()
2098 h->drv[drv_index]->block_size = drvinfo->block_size; cciss_update_drive_info()
2268 h->drv[drv_index]->block_size = 512; cciss_add_controller_node()
2431 drive_info->block_size = 0; cciss_clear_drive_info()
2858 unsigned int block_size, cciss_geometry_inquiry()
2886 drv->block_size = block_size; cciss_geometry_inquiry()
2903 unsigned int *block_size) cciss_read_capacity()
2920 *block_size = be32_to_cpu(*(__be32 *) buf->block_size); cciss_read_capacity()
2924 *block_size = BLOCK_SIZE; cciss_read_capacity()
2930 sector_t *total_size, unsigned int *block_size) cciss_read_capacity_16()
2948 *block_size = be32_to_cpu(*(__be32 *) buf->block_size); cciss_read_capacity_16()
2952 *block_size = BLOCK_SIZE; cciss_read_capacity_16()
2954 dev_info(&h->pdev->dev, " blocks= %llu block_size= %d\n", cciss_read_capacity_16()
2955 (unsigned long long)*total_size+1, *block_size); cciss_read_capacity_16()
2965 unsigned int block_size; cciss_revalidate() local
2989 &total_size, &block_size); cciss_revalidate()
2992 &total_size, &block_size); cciss_revalidate()
2994 cciss_geometry_inquiry(h, logvol, total_size, block_size, cciss_revalidate()
2997 blk_queue_logical_block_size(drv->queue, drv->block_size); cciss_revalidate()
2856 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
2902 cciss_read_capacity(ctlr_info_t *h, int logvol, sector_t *total_size, unsigned int *block_size) cciss_read_capacity() argument
2929 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.4.14/drivers/mtd/nand/brcmnand/
H A Dbrcmnand.c160 unsigned int block_size; member in struct:brcmnand_cfg
1720 u8 block_size = 0, page_size = 0, device_size = 0; brcmnand_set_cfg() local
1727 if (ctrl->block_sizes[i] * 1024 == cfg->block_size) { brcmnand_set_cfg()
1728 block_size = i; brcmnand_set_cfg()
1733 cfg->block_size); brcmnand_set_cfg()
1737 block_size = ffs(cfg->block_size) - ffs(BRCMNAND_MIN_BLOCKSIZE); brcmnand_set_cfg()
1740 if (cfg->block_size < BRCMNAND_MIN_BLOCKSIZE || (ctrl->max_block_size && brcmnand_set_cfg()
1741 cfg->block_size > ctrl->max_block_size)) { brcmnand_set_cfg()
1743 cfg->block_size); brcmnand_set_cfg()
1744 block_size = 0; brcmnand_set_cfg()
1784 (block_size << CFG_BLK_SIZE_SHIFT); brcmnand_set_cfg()
1789 (block_size << CFG_EXT_BLK_SIZE_SHIFT); brcmnand_set_cfg()
1813 cfg->block_size >> 10, brcmnand_print_cfg()
1870 cfg->block_size = mtd->erasesize; brcmnand_setup_dev()
/linux-4.4.14/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::__anon11737::__anon11738
115 u32 block_size; /* Size of a compression block member in struct:_ntfs_inode::__anon11737::__anon11739
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.4.14/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.4.14/include/uapi/linux/
H A Dbcache.h179 __u16 block_size; /* sectors */ member in struct:cache_sb::__anon13923::__anon13924
190 * block_size from the cache device section is still used by
/linux-4.4.14/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.4.14/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.4.14/drivers/staging/comedi/drivers/
H A Dgsc_hpdi.c147 unsigned int block_size; member in struct:hpdi_private
169 for (desc = 0; (next < start || next >= start + devpriv->block_size) && gsc_hpdi_drain_dma()
172 size = devpriv->block_size / sizeof(u32); gsc_hpdi_drain_dma()
460 devpriv->block_size = len; gsc_hpdi_setup_dma_descriptors()
H A Dcb_pcidas64.c1909 unsigned int block_size, requested_block_size; ai_config_block_size() local
1923 block_size = ai_fifo_size(dev) / fifo->num_segments * bytes_in_sample; ai_config_block_size()
1925 data[1] = block_size; ai_config_block_size()
/linux-4.4.14/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.4.14/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.4.14/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.4.14/arch/powerpc/mm/
H A Dhash_utils_64.c417 long unsigned int block_size; htab_dt_scan_hugepage_blocks() local
433 block_size = be64_to_cpu(addr_prop[1]); htab_dt_scan_hugepage_blocks()
434 if (block_size != (16 * GB)) htab_dt_scan_hugepage_blocks()
438 phys_addr, block_size, expected_pages); htab_dt_scan_hugepage_blocks()
440 memblock_reserve(phys_addr, block_size * expected_pages); htab_dt_scan_hugepage_blocks()
441 add_gpage(phys_addr, block_size, expected_pages); htab_dt_scan_hugepage_blocks()
/linux-4.4.14/drivers/video/fbdev/omap2/dss/
H A Dhdmi.h201 u8 block_size; member in struct:hdmi_audio_dma
H A Dhdmi_wp.c236 r = FLD_MOD(r, aud_dma->block_size, 7, 0); hdmi_wp_audio_config_dma()
H A Dhdmi4_core.c837 audio_dma.block_size = 0xC0; hdmi4_audio_config()
H A Dhdmi5_core.c867 audio_dma.block_size = 0xC0; hdmi5_audio_config()
/linux-4.4.14/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.4.14/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.4.14/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.4.14/include/uapi/scsi/
H A Dcxlflash_ioctl.h53 __u64 block_size; /* Returned block size, in bytes */ member in struct:dk_cxlflash_attach
/linux-4.4.14/arch/s390/include/uapi/asm/
H A Dvtoc.h193 __u32 block_size; /* Disk block size */ member in struct:vtoc_cms_label
/linux-4.4.14/drivers/net/irda/
H A Dirda-usb.c1025 unsigned int block_size = 0; stir421x_fw_upload() local
1033 for (i = 0; i < patch_len; i += block_size) { stir421x_fw_upload()
1034 block_size = patch_len - i; stir421x_fw_upload()
1036 if (block_size > STIR421X_PATCH_BLOCK_SIZE) stir421x_fw_upload()
1037 block_size = STIR421X_PATCH_BLOCK_SIZE; stir421x_fw_upload()
1040 memcpy(patch_block, patch + i, block_size); stir421x_fw_upload()
1045 patch_block, block_size, stir421x_fw_upload()
/linux-4.4.14/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.4.14/virt/kvm/arm/
H A Dvgic.c2213 phys_addr_t *addr_ptr, block_size; kvm_vgic_addr() local
2221 block_size = KVM_VGIC_V2_DIST_SIZE; kvm_vgic_addr()
2227 block_size = KVM_VGIC_V2_CPU_SIZE; kvm_vgic_addr()
2234 block_size = KVM_VGIC_V3_DIST_SIZE; kvm_vgic_addr()
2240 block_size = KVM_VGIC_V3_REDIST_SIZE; kvm_vgic_addr()
2259 block_size); kvm_vgic_addr()
/linux-4.4.14/drivers/infiniband/hw/mlx5/
H A Dqp.c2127 static u8 bs_selector(int block_size) bs_selector() argument
2129 switch (block_size) { bs_selector()
2275 u16 block_size = sig_attrs->mem.sig.dif.pi_interval; set_sig_data_segment() local
2284 pr_err("Bad block size given: %u\n", block_size); set_sig_data_segment()
2287 sblock_ctrl->bcount_per_cycle = cpu_to_be32(block_size + set_sig_data_segment()
2290 sblock_ctrl->repeat_count = cpu_to_be32(data_len / block_size); set_sig_data_segment()
2293 data_sentry->bcount = cpu_to_be16(block_size); set_sig_data_segment()
2296 data_sentry->stride = cpu_to_be16(block_size); set_sig_data_segment()
/linux-4.4.14/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.c659 (spi->block_size - (start & (spi->block_size - 1)))); falcon_spi_write_limit()
2165 spi_device->block_size = falcon_spi_device_init()
/linux-4.4.14/arch/arm/mach-omap2/
H A Dcontrol.c86 u32 block_size; member in struct:omap3_scratchpad_sdrc_block
408 sdrc_block_contents.block_size = 0x0; omap3_save_scratchpad_contents()
/linux-4.4.14/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.4.14/arch/arm/mm/
H A Dcache-l2x0.c957 u32 block_size = 0; l2x0_cache_size_of_parse() local
962 of_property_read_u32(np, "cache-block-size", &block_size); l2x0_cache_size_of_parse()
970 if (block_size) { l2x0_cache_size_of_parse()
972 line_size = block_size; l2x0_cache_size_of_parse()
/linux-4.4.14/drivers/gpu/drm/nouveau/
H A Dnouveau_abi16.c139 if (chan->heap.block_size) nouveau_abi16_chan_fini()
/linux-4.4.14/block/
H A Dioctl.c527 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.4.14/fs/xfs/
H A Dxfs_buf.h392 #define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev)
/linux-4.4.14/drivers/iommu/
H A Dio-pgtable-arm.c312 size_t block_size = ARM_LPAE_BLOCK_SIZE(lvl, data); __arm_lpae_map() local
319 if (size == block_size && (size & cfg->pgsize_bitmap)) __arm_lpae_map()
/linux-4.4.14/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.4.14/drivers/net/wireless/ath/ath6kl/
H A Dhtc_mbox.c2785 u32 block_size, ctrl_bufsz; ath6kl_htc_reset() local
2791 block_size = target->dev->ar->mbox_info.block_size; ath6kl_htc_reset()
2793 ctrl_bufsz = (block_size > HTC_MAX_CTRL_MSG_LEN) ? ath6kl_htc_reset()
2794 (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()
/linux-4.4.14/drivers/staging/rts5208/
H A Dms.c2160 u16 i, reg_addr, block_size; reset_ms() local
2307 block_size = ((u16)ptr[6] << 8) | ptr[7]; reset_ms()
2308 if (block_size == 0x0010) { reset_ms()
2312 } else if (block_size == 0x0008) { reset_ms()
/linux-4.4.14/drivers/infiniband/ulp/isert/
H A Dib_isert.c1843 u32 block_size = se_cmd->se_dev->dev_attrib.block_size + 8; isert_check_pi_status() local
1857 do_div(sec_offset_err, block_size); isert_check_pi_status()
2597 domain->sig.dif.pi_interval = se_cmd->se_dev->dev_attrib.block_size; isert_set_dif_domain()
/linux-4.4.14/drivers/scsi/qla2xxx/
H A Dtcm_qla2xxx.c384 cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size; tcm_qla2xxx_write_pending()
555 cmd->blk_sz = se_cmd->se_dev->dev_attrib.block_size; tcm_qla2xxx_queue_data_in()
/linux-4.4.14/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.4.14/drivers/scsi/cxlflash/
H A Dsuperpipe.c1440 attach->block_size = gli->blk_len; cxlflash_disk_attach()
1453 __func__, ctxid, fd, attach->block_size, rc, attach->last_lba); cxlflash_disk_attach()
/linux-4.4.14/drivers/net/wireless/iwlwifi/mvm/
H A Dfw-api.h401 * @block_size: the block size in powers of 2
407 __le32 block_size; member in struct:iwl_fw_paging_cmd
/linux-4.4.14/drivers/scsi/qla4xxx/
H A Dql4_fw.h312 uint32_t block_size; member in struct:qla_fdt_layout

Completed in 8170 milliseconds

12