wrap
unsigned int wrap = 0; /* bit mask: requests behind the disk head? */
wrap |= BFQ_RQ1_WRAP;
wrap |= BFQ_RQ2_WRAP;
switch (wrap) {
unsigned int wrap = 0;
wrap = ec->memblocksize * ec->memblocks;
ec->memlocation = ec->memlocation % wrap;
pci_write_config_dword(core->bus->host_pci, win2, core->wrap);
core->wrap = tmp;
core->wrap = tmp;
if (core->wrap) {
core->io_wrap = ioremap(core->wrap,
frame->ring.wrap =
ring->wrap = BITS_PER_TYPE(ring->size) - ilog2(size);
return (next - prev) << ring->wrap;
u32 wrap;
ring->wrap = BITS_PER_TYPE(ring->size) - ilog2(sz);
struct trbe_buf *buf, bool wrap)
if (wrap)
bool wrap = false;
wrap = true;
size = trbe_get_trace_size(handle, buf, wrap);
wrap : 1,
return scnprintf(buf, PAGE_SIZE, "%d\n", msc->wrap);
msc->wrap = !!val;
static DEVICE_ATTR_RW(wrap);
if (msc->wrap)
struct vdec_hevc_slice_mem wrap;
inst->vsi_core->wrap.dma_addr = inst->wrap_addr.dma_addr;
inst->vsi_core->wrap.size = inst->wrap_addr.size;
bool seekup, bool wrap)
seekup << 3 | wrap << 2,
bool seekup, bool wrap)
seekup << 3 | wrap << 2,
bool wrap = false;
if (!wrap && bit + bit_count >= part->usage_bit_count) {
wrap = true;
if (wrap && bit + bit_count >= start_bit)
u32 base, wrap;
err = brcmf_chip_dmp_get_regaddr(ci, &eromaddr, &base, &wrap);
core = brcmf_chip_add_core(ci, id, base, wrap);
struct eeprom_pda_wrap *wrap;
wrap = (struct eeprom_pda_wrap *) eeprom;
entry = (void *)wrap->data + le16_to_cpu(wrap->len);
topaz_skb2rbd_attach(struct qtnf_pcie_topaz_state *ts, u16 index, u32 wrap)
rxbd->info = cpu_to_le32(QTN_BD_EMPTY | wrap);
uint8_t wrap[512]; /* Temp area for q-wrap around*/
#define csio_q_eq_wrap(__hw, __idx) ((__hw)->wrm.q_arr[(__idx)]->un.eq.wrap)
port_id_t wrap = {}, nxt_d_id;
wrap.b24 = new_fcport->d_id.b24;
wrap.b24 = new_fcport->d_id.b24;
} else if (new_fcport->d_id.b24 == wrap.b24) {
(wrap << CANVAS_WRAP_BIT) |
unsigned int wrap,
wrap = kzalloc_obj(*wrap);
if (!wrap)
res = wrap->dev_res;
wrap->dev_res[RES_IRQ_HOST_ID].start = pdev->irq;
wrap->dev_res[RES_IRQ_HOST_ID].name = "host";
wrap->dev_res[RES_IRQ_HOST_ID].flags = IORESOURCE_IRQ;
wrap->dev_res[RES_IRQ_PERIPHERAL_ID].start = pdev->irq;
wrap->dev_res[RES_IRQ_PERIPHERAL_ID].name = "peripheral";
wrap->dev_res[RES_IRQ_PERIPHERAL_ID].flags = IORESOURCE_IRQ;
wrap->dev_res[RES_IRQ_OTG_ID].start = pdev->irq;
wrap->dev_res[RES_IRQ_OTG_ID].name = "otg";
wrap->dev_res[RES_IRQ_OTG_ID].flags = IORESOURCE_IRQ;
wrap->devfn = pdev->devfn;
plat_info.res = wrap->dev_res;
plat_info.num_res = ARRAY_SIZE(wrap->dev_res);
wrap->plat_dev = platform_device_register_full(&plat_info);
if (IS_ERR(wrap->plat_dev)) {
err = PTR_ERR(wrap->plat_dev);
kfree(wrap);
pci_set_drvdata(pdev, wrap);
struct cdns3_wrap *wrap;
wrap = (struct cdns3_wrap *)pci_get_drvdata(pdev);
if (wrap->devfn == pdev->devfn)
platform_device_unregister(wrap->plat_dev);
kfree(wrap);
struct cdns3_wrap *wrap;
wrap = pci_get_drvdata(func);
eem->port.wrap = eem_wrap;
ncm->port.wrap = ncm_wrap_ntb;
rndis->port.wrap = rndis_add_header;
dev->wrap = link->wrap;
dev->wrap = NULL;
if (dev->wrap) {
skb = dev->wrap(dev->port_usb, skb);
struct sk_buff *(*wrap)(struct gether *, struct sk_buff *skb);
struct sk_buff *(*wrap)(struct gether *port,
u32 wrap = 0, skip = 0;
wrap = mod;
if (unlikely(start + span - period >= mod + wrap)) {
urb, start, span - period, mod + wrap);
int from, wrap, from_off, avail;
wrap = vga_rolled_over + c->vc_size_row;
wrap = vga_vram_size;
from_off = (vorigin - from + wrap) % wrap + lines * c->vc_size_row;
avail = (origin - from + wrap) % wrap;
c->vc_visible_origin = vga_vram_base + (from + from_off) % wrap;
revoke = (wrap) ? (a || b) : (a && b);
int wrap, a, b, revoke;
wrap = (rr->rr_where < jd->jd_replay_tail);
wrap(journal, *next_log_block);
wrap(journal, *next_log_block);
wrap(journal, next_log_block);
wrap(journal, next_log_block);
spinlock_t *lock, bool wrap)
if (!wrap)
struct nilfs_palloc_req *req, bool wrap)
if (group >= ngroups && wrap) {
wrap);
struct nilfs_palloc_req *req, bool wrap);
u32 wrap;
unsigned int wrap, unsigned int blkmode,
struct __ssb_dev_wrapper *wrap;
wrap = container_of(dev, struct __ssb_dev_wrapper, dev);
return wrap->sdev;
DEFINE_GSSAPI_EVENT(wrap);
DEFINE_SVC_GSSAPI_EVENT(wrap);
__u16 wrap;
u64 res, wrap, new_mask, new_epoch, cyc, ns;
wrap = clocks_calc_max_nsecs(new_mult, new_shift, 0, new_mask, NULL);
cd.wrap_kt = ns_to_ktime(wrap);
bits, r, r_unit, res, wrap);
unsigned int hint, bool wrap)
wrap = wrap && hint;
if (hint && wrap) {
bool wrap)
alloc_hint, wrap);
if (!sbitmap_deferred_clear(map, depth, alloc_hint, wrap))
bool wrap)
alloc_hint, wrap);
unsigned int depth, unsigned int alloc_hint, bool wrap)
if (!wrap && alloc_hint)
volatile int neg = -1, wrap = 4;
val2 <<= wrap;
} wrap;
memset(&wrap, 0xFF, sizeof(wrap));
KUNIT_EXPECT_EQ_MSG(test, wrap.canary1, ULONG_MAX,
KUNIT_EXPECT_EQ_MSG(test, wrap.canary2, ULONG_MAX,
strtomem(wrap.output, input);
KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
for (size_t i = 2; i < sizeof(wrap.output); i++)
KUNIT_EXPECT_EQ(test, wrap.output[i], 0xFF);
KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
memset(&wrap, 0xFF, sizeof(wrap));
strtomem(wrap.output, truncate);
KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
for (size_t i = 0; i < sizeof(wrap.output); i++)
KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
memset(&wrap, 0xFF, sizeof(wrap));
strtomem_pad(wrap.output, input, 0xAA);
KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
for (size_t i = 2; i < sizeof(wrap.output); i++)
KUNIT_EXPECT_EQ(test, wrap.output[i], 0xAA);
KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
memset(&wrap, 0xFF, sizeof(wrap));
strtomem(wrap.output, truncate);
KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
for (size_t i = 0; i < sizeof(wrap.output); i++)
KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
if (state->wrap == 0) {
state->wrap = 0;
if (state->wrap) {
state->wrap = (windowBits >> 4) + 1;
if (INFLATE_NEED_CHECKSUM(strm) && state->wrap && out)
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
unsigned int qsize, sack, wrap, to, max_mtu, if_mtu;
wrap = RXRPC_SACK_SIZE - sack;
memcpy(sackp, call->ackr_sack_table + sack, wrap);
memcpy(sackp + wrap, call->ackr_sack_table, to - wrap);
u16 wrap; /* window wrap sequence number */
cdc.prod.wrap = curs.wrap;
cdc.cons.wrap = curs.wrap;
if (old->wrap != new->wrap)
if (old->wrap > new->wrap ||
(old->wrap == new->wrap && old->count > new->count))
if (old->wrap < new->wrap)
(new->wrap - old->wrap - 1) * size,
if (old->wrap > new->wrap) /* wrap has switched from 0xffff to 0x0000 */
(new->wrap + 0xffff - old->wrap) * size,
peer->wrap = htons(save->wrap);
temp.wrap = ntohs(net.wrap);
if ((old.wrap > temp.wrap) && temp.wrap)
if ((old.wrap == temp.wrap) &&
temp.wrap = peer->prod.wrap;
temp.wrap = peer->cons.wrap;
__be16 wrap;
u16 wrap;
curs->wrap++;
.rx_prod.wrap = conn->local_rx_ctrl.prod.wrap,
.rx_cons.wrap = conn->local_rx_ctrl.cons.wrap,
.tx_prod.wrap = conn->local_tx_ctrl.prod.wrap,
.tx_cons.wrap = conn->local_tx_ctrl.cons.wrap,
.tx_prep.wrap = conn->tx_curs_prep.wrap,
.tx_sent.wrap = conn->tx_curs_sent.wrap,
.tx_fin.wrap = conn->tx_curs_fin.wrap,
if (prod.wrap == cons.wrap) {
u32 (*wrap)(struct krb5_ctx *kctx, int offset,
.wrap = gss_krb5_wrap_v2,
.wrap = gss_krb5_wrap_v2,
.wrap = gss_krb5_wrap_v2,
.wrap = gss_krb5_wrap_v2,
.wrap = gss_krb5_wrap_v2,
return kctx->gk5e->wrap(kctx, offset, buf, pages);
.wrap = gss_krb5_wrap_v2,
PROC(WRAP, wrap),
int wrap;
wrap = seq_hi - replay_esn->seq_hi;
if ((!wrap && seq > replay_esn->seq) || wrap > 0) {
if (likely(!wrap))
if (unlikely(wrap > 0))
unsigned int wrap = subs->buffer_bytes;
int idx = (src_idx + subs->dsd_dop.byte_idx - 1) % wrap;