entry_size
total_size -= entry_size(&entry->req_packet, &entry->reply_packet);
size_t esize = entry_size(req_packet, reply_packet);
size_t esize = entry_size(req, rep);
result = entry_size(&req, NULL);
result = entry_size(&req, &rep);
assert_int_equal(total_size, entry_size(&req1, &rep1));
assert_int_equal(total_size, entry_size(&req1, &rep1));
assert_int_equal(total_size, entry_size(&req, &rep));
assert_int_equal(total_size, entry_size(&req, NULL));
size_t e1_size = entry_size(&req1, &rep1);
size_t e2_size = entry_size(&req2, NULL);
size_t e1_size = entry_size(&req1, &rep1);
size_t e2_size = entry_size(&req2, NULL);
size_t hdr_size = 0, entry_size = 0;
entry_size = sizeof(struct scsi_defect_desc_block);
entry_size = sizeof(struct scsi_defect_desc_long_block);
entry_size = sizeof(struct scsi_defect_desc_phys_sector);
entry_size = sizeof(struct scsi_defect_desc_bytes_from_index);
max_possible_size = (hdr_max / entry_size) * entry_size;
num_returned = returned_length / entry_size;
num_valid /= entry_size;
multiboot_uint32_t entry_size;
int i, entry_size, err, t, tuple_size, tuples;
entry_size = tuple_size / sizeof(pcell_t);
for (i = 0, t = 0; t < tuples; i += entry_size, t++) {
int entry_size, cam_quirkmatch_t *comp_func)
for (; num_entries > 0; num_entries--, quirk_table += entry_size) {
int entry_size, cam_quirkmatch_t *comp_func);
size_t entry_size);
size_t entry_size);
size_t entry_size)
(const struct bhnd_device *) ((const char *) entry + entry_size))
size_t entry_size)
if ((dent = bhnd_device_lookup(dev, table, entry_size)) == NULL)
u16 entry_size;
ctxm->entry_size = le16_to_cpu(resp->entry_size);
ctxm->entry_size = le16_to_cpu(resp->qp_entry_size);
ctxm->entry_size = le16_to_cpu(resp->srq_entry_size);
ctxm->entry_size = le16_to_cpu(resp->cq_entry_size);
ctxm->entry_size = le16_to_cpu(resp->vnic_entry_size);
ctxm->entry_size = le16_to_cpu(resp->stat_entry_size);
ctxm->entry_size = le16_to_cpu(resp->tqm_entry_size);
ctxm->entry_size = le16_to_cpu(resp->mrav_entry_size);
ctxm->entry_size = le16_to_cpu(resp->tim_entry_size);
req.qp_entry_size = cpu_to_le16(ctxm->entry_size);
req.srq_entry_size = cpu_to_le16(ctxm->entry_size);
req.cq_entry_size = cpu_to_le16(ctxm->entry_size);
req.mrav_entry_size = cpu_to_le16(ctxm->entry_size);
req.tim_entry_size = cpu_to_le16(ctxm->entry_size);
req.vnic_entry_size = cpu_to_le16(ctxm->entry_size);
req.stat_entry_size = cpu_to_le16(ctxm->entry_size);
req.tqm_entry_size = cpu_to_le16(ctxm->entry_size);
req.entry_size = cpu_to_le16(ctxm->entry_size);
uint16_t entry_size;
uint16_t entry_size;
if (!ctxm->entry_size || !ctx_pg)
mem_size = entries * ctxm->entry_size;
for (i = 0; i < len; i += ctxm->entry_size)
const uint8_t entry_size)
pri_cli_nig = ((uint64_t)(cos + cos_offset)) << (entry_size *
int entry_size;
buf->entry_size = dev->dev->caps.cqe_size;
mlx4_buf_free(dev->dev, nent * buf->entry_size, &buf->buf);
mlx4_buf_free(dev->dev, (cqe + 1) * buf->entry_size, &buf->buf);
int cqe_size = cq->buf.entry_size;
if (cq->buf.entry_size == 64)
return mlx4_buf_offset(&buf->buf, n * buf->entry_size);
struct mlx4_cqe *tcqe = ((cq->buf.entry_size == 64) ? (cqe + 1) : cqe);
int cqe_inc = cq->buf.entry_size == 64 ? 1 : 0;
size_t entry_size[2];
entry_size[0] = sizeof(*csb_atok_base);
entry_size[1] = sizeof(*csb_ktoa_base);
size_t csb_size = tot_rings * entry_size[i];
if ((uintptr_t)csb_start[i] & (entry_size[i]-1)) {
uint32_t entry_size;
uint32_t entry_size; /*<< entry size */
uint32_t entry_size;
uint32_t entry_size;
mq->entry_size = OCS_HW_MQ_DEPTH;
mq->entry_size,
for (i = 0; sc->lct[i].entry_size == I2O_LCT_ENTRYSIZE; i++) {
u_int32_t entry_size:16;
offset += IDLE_CHK_RESULT_REG_HDR_DWORDS + reg->entry_size;
reg_hdr->size = reg->entry_size;
padded_entry_size = reg->entry_size > 1 ? OSAL_ROUNDUP_POW_OF_TWO(reg->entry_size) : 1;
if (next_reg_offset + reg->entry_size >= IDLE_CHK_MAX_ENTRIES_SIZE) {
next_reg_offset += ecore_grc_dump_addr_range(p_hwfn, p_ptt, cond_reg_values + next_reg_offset, dump, addr, reg->entry_size, wide_bus);
u8 entry_size /* size of registers entry (in dwords) */;
u16 entry_size; /* Size of an element in the queue */
+ entry->hdr.entry_size);
+ entry->hdr.entry_size);
+ entry->hdr.entry_size);
uint32_t entry_size ;
vm_size_t entry_size;
entry_size = tsize2size(entry_tsize);
pa_end = pa_start + entry_size;
size_t entry_size;
entry_size = 0;
entry_size += HASHTABLE_ENTRY_SIZE(ht_item, data);
common_entry->items_size -= entry_size;