/linux-4.4.14/fs/befs/ |
H A D | super.c | 38 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 D | befs.h | 33 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 D | debug.c | 167 befs_debug(sb, " block_size %u", fs32_to_cpu(sb, sup->block_size)); befs_dump_super_block()
|
H A D | befs_fs_types.h | 117 fs32 block_size; member in struct:__anon11349
|
H A D | datastream.c | 142 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 D | linuxvfs.c | 377 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 D | tape_char.c | 97 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 D | tape_proc.c | 60 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 D | sclp_cmd.c | 408 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 D | tape_std.c | 224 * 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 D | tape.h | 174 int block_size; /* of size block_size. */ member in struct:tape_char_data
|
H A D | tape_core.c | 163 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size); tape_blocksize_show()
|
/linux-4.4.14/drivers/crypto/ccp/ |
H A D | ccp-crypto-sha.c | 64 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 D | ccp-crypto-aes-cmac.c | 65 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 D | ccp-ops.c | 751 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 D | wilc_sdio.c | 18 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 D | linux_wlan_sdio.c | 96 func->cur_blksize = cmd->block_size; linux_sdio_cmd53() 98 size = cmd->count * cmd->block_size; linux_sdio_cmd53()
|
H A D | wilc_wlan_if.h | 71 u32 block_size; member in struct:__anon10892
|
/linux-4.4.14/drivers/net/wireless/rsi/ |
H A D | rsi_91x_usb_ops.c | 41 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 D | rsi_91x_sdio_ops.c | 84 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 D | rsi_91x_sdio.c | 569 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 D | lz4_wrapper.c | 56 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 D | lzo_wrapper.c | 43 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 D | squashfs_fs_sb.h | 35 int block_size; member in struct:squashfs_cache 74 unsigned int block_size; member in struct:squashfs_sb_info
|
H A D | super.c | 148 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 D | cache.c | 233 * 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 D | file.c | 434 (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 D | xz_wrapper.c | 82 opts->dict_size = max_t(int, msblk->block_size, squashfs_xz_comp_opts()
|
H A D | squashfs_fs.h | 249 __le32 block_size; member in struct:squashfs_super_block
|
/linux-4.4.14/drivers/md/persistent-data/ |
H A D | dm-btree-spine.c | 20 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 D | dm-block-manager.h | 35 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 D | dm-space-map-common.c | 24 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 D | dm-btree.c | 114 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 D | dm-space-map-common.h | 62 uint32_t block_size; member in struct:ll_disk
|
H A D | dm-block-manager.c | 371 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 D | ide-gd.h | 33 int blocks, block_size, bs_factor; member in struct:ide_disk_obj
|
H A D | ide-floppy.c | 354 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 D | blocklayoutxdr.c | 93 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 D | blocklayoutxdr.h | 45 u32 block_size);
|
H A D | blocklayout.c | 53 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 D | target_core_sbc.c | 77 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 D | target_core_file.c | 250 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 D | target_core_iblock.c | 206 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 D | target_core_rd.c | 253 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 D | target_core_spc.c | 513 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 D | target_core_xcopy.c | 629 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 D | target_core_device.c | 536 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 D | target_core_transport.c | 816 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 D | target_core_user.c | 1081 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 D | target_core_configfs.c | 493 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 D | mm.c | 131 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 D | dma-dw.h | 43 * @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 D | comedi_buf.c | 314 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 D | rfd_ftl.c | 25 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 D | sm_ftl.c | 200 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 D | sm_ftl.h | 35 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 D | mm.h | 23 u32 block_size; member in struct:nvkm_mm
|
/linux-4.4.14/block/partitions/ |
H A D | mac.h | 39 __be16 block_size; member in struct:mac_driver_desc
|
H A D | mac.c | 51 secsize = be16_to_cpu(md->block_size); mac_partition()
|
H A D | ibm.c | 255 blocksize = label->cms.block_size; find_cms1_partitions()
|
/linux-4.4.14/drivers/gpu/drm/vmwgfx/device_include/ |
H A D | svga3d_surfacedefs.h | 205 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 D | fwio.c | 185 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 D | intel_bios.c | 152 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 D | intel_bios.h | 241 * number = (block_size - sizeof(bdb_general_definitions))/
|
/linux-4.4.14/drivers/scsi/esas2r/ |
H A D | esas2r_targdb.c | 146 || 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 D | esas2r_main.c | 1413 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 D | atvda.h | 195 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 D | esas2r_disc.c | 656 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 D | esas2r.h | 637 u32 block_size; member in struct:esas2r_target 733 u32 block_size; member in struct:esas2r_disc_context
|
H A D | esas2r_io.c | 596 sgc->length = startlba * t->block_size; esas2r_build_sg_list_prd()
|
/linux-4.4.14/drivers/dma/ |
H A D | coh901318_lli.c | 199 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 D | dm-bufio.c | 93 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 D | dm-era-target.c | 266 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 D | dm-bufio.h | 24 dm_bufio_client_create(struct block_device *bdev, unsigned block_size,
|
H A D | dm-cache-policy-internal.h | 143 sector_t origin_size, sector_t block_size);
|
H A D | dm-cache-target.c | 2413 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 D | dm-thin-metadata.c | 225 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 D | dm-thin.c | 2665 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 D | dm-cache-policy.h | 257 sector_t block_size);
|
/linux-4.4.14/drivers/block/rsxx/ |
H A D | config.c | 36 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 D | rsxx_cfg.h | 44 __u32 block_size; member in struct:card_cfg_data
|
H A D | dev.c | 286 blk_size = card->config.data.block_size; rsxx_setup_dev()
|
/linux-4.4.14/fs/isofs/ |
H A D | compress.c | 52 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 D | core.c | 332 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 D | c2port-duramar2150.c | 105 .block_size = 512, /* bytes */
|
/linux-4.4.14/drivers/scsi/ |
H A D | st.c | 692 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 D | osst.c | 727 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 D | ps3rom.c | 56 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 D | st.h | 177 int block_size; member in struct:scsi_tape
|
H A D | dpti.h | 184 u32 block_size; member in struct:adpt_device
|
H A D | osst.h | 578 int block_size; member in struct:osst_tape
|
H A D | hpsa_cmd.h | 703 __le16 block_size; /* sector size in bytes */ member in struct:bmic_identify_physical_device
|
H A D | gdth.h | 536 u16 block_size; /* cache block size */ member in struct:__anon9400
|
/linux-4.4.14/drivers/crypto/ |
H A D | atmel-sha.c | 96 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 D | n2_core.c | 818 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 D | atmel-aes.c | 88 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 D | atmel-tdes.c | 81 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 D | sahara.c | 165 * @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 D | super.c | 116 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 D | journal.c | 135 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 D | sysfs.c | 40 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 D | bcache.h | 509 /* log2(block_size), in sectors */ 692 #define block_bytes(c) ((c)->sb.block_size << 9)
|
H A D | request.c | 389 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 D | alloc.c | 640 if (b->sectors_free < c->sb.block_size) bch_alloc_sectors()
|
H A D | btree.c | 205 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 D | dasd_diag.h | 59 u32 block_size; member in struct:dasd_diag_init_io
|
H A D | dasd_diag.c | 116 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 D | intel_bios.c | 79 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 D | intel_bios.h | 290 * number = (block_size - sizeof(bdb_general_definitions))/
|
/linux-4.4.14/include/linux/ |
H A D | c2port.h | 43 unsigned short block_size; /* flash block size in bytes */ member in struct:c2port_ops
|
H A D | pstore_ram.h | 30 int block_size; member in struct:persistent_ram_ecc_info
|
/linux-4.4.14/sound/atmel/ |
H A D | ac97c.c | 321 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 D | ram_core.c | 162 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 D | ram.c | 562 cxt->ecc_info.ecc_size, cxt->ecc_info.block_size); ramoops_probe()
|
/linux-4.4.14/fs/ufs/ |
H A D | super.c | 758 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 D | ms_block.h | 80 unsigned short block_size; member in struct:ms_boot_attr_info 174 int block_size; member in struct:msb_data
|
H A D | ms_block.c | 982 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 D | mspro_block.c | 75 __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 D | tail_conversion.c | 212 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 D | item_ops.c | 19 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 D | stree.c | 1547 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 D | platform.c | 128 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 D | core.c | 723 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 D | regs.h | 246 unsigned int block_size; member in struct:dw_dma_chan
|
/linux-4.4.14/fs/ceph/ |
H A D | ioctl.c | 206 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 D | ioctl.h | 62 __u64 block_size; /* out: block length */ member in struct:ceph_ioctl_dataloc
|
/linux-4.4.14/sound/oss/dmasound/ |
H A D | dmasound_core.c | 485 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 D | dmasound_paula.c | 471 : 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 D | dmasound_q40.c | 411 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 D | dmasound.h | 222 int block_size; /* internal block size in bytes */ member in struct:sound_queue
|
H A D | dmasound_atari.c | 1177 : 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 D | qat_algs.c | 153 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 D | gus_pcm.c | 55 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 D | vub300.c | 73 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 D | android-goldfish.c | 370 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 D | ushc.c | 70 __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 D | omap.c | 950 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 D | aachba.c | 626 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 D | aacraid.h | 920 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 D | jl2005bcd.c | 50 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 D | target_core_backend.h | 99 struct request_queue *q, int block_size);
|
H A D | target_core_base.h | 681 u32 block_size; member in struct:se_dev_attrib
|
/linux-4.4.14/drivers/block/ |
H A D | cciss.c | 179 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 D | cciss_cmd.h | 108 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 D | cciss.h | 37 int block_size; member in struct:_drive_info_struct
|
/linux-4.4.14/drivers/mtd/nand/brcmnand/ |
H A D | brcmnand.c | 160 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 D | dir.c | 358 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 D | inode.c | 410 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 D | index.c | 315 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 D | compress.c | 491 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 D | inode.h | 104 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 D | logfile.c | 734 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 D | aops.c | 144 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 D | attrib.c | 719 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 D | onenand_base.c | 2242 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 D | bcache.h | 179 __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 D | rtas_flash.c | 171 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 D | omap1_camera.c | 302 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 D | gsc_hpdi.c | 147 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 D | cb_pcidas64.c | 1909 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 D | btree.c | 74 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 D | hfsplus_fs.h | 392 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 D | cvmx-fpa.h | 275 * @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 D | at73c213.c | 258 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 D | hash_utils_64.c | 417 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 D | hdmi.h | 201 u8 block_size; member in struct:hdmi_audio_dma
|
H A D | hdmi_wp.c | 236 r = FLD_MOD(r, aud_dma->block_size, 7, 0); hdmi_wp_audio_config_dma()
|
H A D | hdmi4_core.c | 837 audio_dma.block_size = 0xC0; hdmi4_audio_config()
|
H A D | hdmi5_core.c | 867 audio_dma.block_size = 0xC0; hdmi5_audio_config()
|
/linux-4.4.14/drivers/net/wireless/ |
H A D | mwl8k.c | 653 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 D | p54usb.c | 504 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 D | readpage.c | 13 * should only be hit when page_size != block_size.
|
H A D | ext4_extents.h | 63 * block_size % 12 >= 4 for at least all powers of 2 greater than 512, which
|
/linux-4.4.14/include/uapi/scsi/ |
H A D | cxlflash_ioctl.h | 53 __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 D | vtoc.h | 193 __u32 block_size; /* Disk block size */ member in struct:vtoc_cms_label
|
/linux-4.4.14/drivers/net/irda/ |
H A D | irda-usb.c | 1025 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 D | keystore.c | 595 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 D | vgic.c | 2213 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 D | qp.c | 2127 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 D | nic.h | 215 * @block_size: Write block size (in bytes). 225 unsigned int block_size; member in struct:falcon_spi_device
|
H A D | falcon.c | 659 (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 D | control.c | 86 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 D | gpmi-lib.c | 254 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 D | cache-l2x0.c | 957 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 D | nouveau_abi16.c | 139 if (chan->heap.block_size) nouveau_abi16_chan_fini()
|
/linux-4.4.14/block/ |
H A D | ioctl.c | 527 return put_int(arg, block_size(bdev)); blkdev_ioctl()
|
H A D | compat_ioctl.c | 717 return compat_put_int(arg, block_size(bdev)); compat_blkdev_ioctl()
|
/linux-4.4.14/fs/xfs/ |
H A D | xfs_buf.h | 392 #define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev)
|
/linux-4.4.14/drivers/iommu/ |
H A D | io-pgtable-arm.c | 312 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 D | drxk_hard.c | 440 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 D | htc_mbox.c | 2785 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 D | core.h | 522 u32 block_size; member in struct:ath6kl_mbox_info
|
H A D | hif.c | 683 dev->htc_cnxt->block_sz = dev->ar->mbox_info.block_size; ath6kl_hif_setup()
|
/linux-4.4.14/drivers/staging/rts5208/ |
H A D | ms.c | 2160 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 D | ib_isert.c | 1843 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 D | tcm_qla2xxx.c | 384 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 D | vxge-config.c | 1154 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 D | superpipe.c | 1440 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 D | fw-api.h | 401 * @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 D | ql4_fw.h | 312 uint32_t block_size; member in struct:qla_fdt_layout
|