bitmap_weight
return bitmap_weight(arm_pmu->cntr_mask, ARMV8_PMU_MAX_GENERAL_COUNTERS);
int nr_io_pics = bitmap_weight(loongson_sysconf.cores_io_master, NR_CPUS);
*val = bitmap_weight(tbl->it_map, tbl->it_size);
return bitmap_weight(apic_maps[at_level].map, lvlid);
#define domain_weight(_dom) bitmap_weight(apic_maps[_dom].map, MAX_LOCAL_APIC)
return bitmap_weight(numa_phys_nodes_parsed.bits, MAX_NUMNODES);
numvalid = bitmap_weight(valid, numprops);
count += bitmap_weight(bm, n * BITS_PER_LONG);
bits += bitmap_weight(p_addr, BITS_PER_PAGE);
bits += bitmap_weight(p_addr, last_word * BITS_PER_LONG);
if (bitmap_weight(used_classes, 256) <= 1) {
queues = bitmap_weight(cmd_q->lsbmask, MAX_LSB_CNT);
qlsb_wgt = bitmap_weight(cmd_q->lsbmask, MAX_LSB_CNT);
n_lsbs = bitmap_weight(lsb_pub, MAX_LSB_CNT);
ch_count -= bitmap_weight(ud->bchan_map, ud->bchan_cnt);
ch_count -= bitmap_weight(ud->tchan_map, ud->tchan_cnt);
ch_count -= bitmap_weight(ud->rchan_map, ud->rchan_cnt);
ud->tchan_cnt - bitmap_weight(ud->tchan_map,
ud->rchan_cnt - bitmap_weight(ud->rchan_map,
ud->rflow_cnt - bitmap_weight(ud->rflow_gp_map,
ud->bchan_cnt - bitmap_weight(ud->bchan_map,
ud->tchan_cnt - bitmap_weight(ud->tchan_map,
ud->rchan_cnt - bitmap_weight(ud->rchan_map,
ud->tchan_cnt - bitmap_weight(ud->tchan_map,
ud->rchan_cnt - bitmap_weight(ud->rchan_map,
cnt = num_bits - bitmap_weight((unsigned long *)flash_buf, num_bits);
chip->gc.ngpio = bitmap_weight(chip->map, 64);
bitmap_weight(adev->gfx.mec_bitmap[j].queue_bitmap, AMDGPU_MAX_COMPUTE_QUEUES));
bitmap_weight(adev->gfx.me.queue_bitmap, AMDGPU_MAX_GFX_QUEUES);
return bitmap_weight(dqm->dev->kfd->shared_resources.cp_queue_bitmap,
&(__regs)->buf[bitmap_weight(dptun_info_regs, (__address) - DP_TUNNELING_BASE)]; \
return bitmap_weight(p->bitmap, display_platforms_num_bits());
drm_dbg_kms(display->drm, "%s (%d):\n", prefix, bitmap_weight(mask->bits, POWER_DOMAIN_NUM));
return bitmap_weight(sseu->subslice_mask.xehp,
bitmap_weight(sseu->geometry_subslice_mask.xehp,
bitmap_weight(sseu->compute_subslice_mask.xehp,
int inuse = bitmap_weight(cs, smp->blk_cnt);
bitmap_weight(state->state, smp->blk_cnt));
avail = cnt - bitmap_weight(state->state, cnt);
if (bitmap_weight(stream->data_drop.mask, XE_MAX_DSS_FUSE_BITS)) {
num_xecores = bitmap_weight(all_xecores, XE_MAX_DSS_FUSE_BITS);
weight = bitmap_weight(bitmap, allvfs);
used = bitmap_weight(dbm->bitmap, dbm->count);
weight = bitmap_weight(dbm->bitmap, dbm->count);
unsigned int weight = bitmap_weight(idm->bitmap, idm->total);
num_eus = bitmap_weight(gt->fuse_topo.eu_mask_per_dss,
st->fifo_set_size = bitmap_weight(active_scan_mask,
st->fifo_set_size = bitmap_weight(indio_dev->active_scan_mask,
st->fifo_set_size = bitmap_weight(indio_dev->active_scan_mask,
num_en_chn = bitmap_weight(indio_dev->active_scan_mask,
enabled = bitmap_weight(scan_mask, masklength);
if (sinc3_count && sinc3_count < bitmap_weight(scan_mask, indio_dev->num_channels)) {
scan_count = bitmap_weight(active_scan_mask,
st->transfer_size = bitmap_weight(scan_mask,
return bitmap_weight(mask, iio_get_masklength(indio_dev)) <= sigma_delta->num_slots;
idev->num_channels = bitmap_weight(&st->channels_mask,
indio_dev->num_channels = bitmap_weight(&channel_map,
unsigned long numvals = bitmap_weight(st->current_mode->modemask,
numelements = bitmap_weight(modemask, MAX1363_MAX_CHANNELS);
const int map_chans = bitmap_weight(mask, LRADC_MAX_TOTAL_CHANS);
adc->num_conv = bitmap_weight(scan_mask, iio_get_masklength(indio_dev));
adc->nconv = bitmap_weight(scan_mask, iio_get_masklength(indio_dev));
n = bitmap_weight(mask, iio_get_masklength(indio_dev));
unsigned int measurements = bitmap_weight(indio_dev->active_scan_mask,
return bitmap_weight(mask, iio_get_masklength(indio_dev)) == 1;
bitmap_weight(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER) == 1;
ports = bitmap_weight(actv_ports.ports, dev->caps.num_ports);
events += bitmap_weight(dev->relbit, REL_CNT);
item->num_subpackets = bitmap_weight(item->subpacket_map,
rdesc->num_registers = bitmap_weight(presence_map,
return bitmap_weight(cmd->region_map, cmd->nr_regions);
segs_used = bitmap_weight(cache->seg_map, cache->n_segs);
bitmap_weight(cache->seg_map, cache->n_segs),
nr_reset = bitmap_weight(need_reset, nr_zones);
if (msb->block_count - bitmap_weight(msb->used_blocks_bitmap,
nfc->rule_cnt = bitmap_weight(priv->cfp.unique,
shift = bitmap_weight(&mask, 16);
hweight = bitmap_weight(aq_nic->active_vlans, VLAN_N_VID);
if (bitmap_weight(adapter->fwd_bitmask, adapter->num_rx_pools) == 1) {
num_rx_pools = bitmap_weight(adapter->fwd_bitmask,
if (!bitmap_weight(lmac->rx_fc_pfvf_bmap.bmap, lmac->rx_fc_pfvf_bmap.max))
if (!rx_pause && bitmap_weight(lmac->rx_fc_pfvf_bmap.bmap, lmac->rx_fc_pfvf_bmap.max)) {
if (!tx_pause && bitmap_weight(lmac->tx_fc_pfvf_bmap.bmap, lmac->tx_fc_pfvf_bmap.max)) {
bw0 = bitmap_weight(sb->b0map, npc_priv->subbank_depth);
bw1 = bitmap_weight(sb->b1map, npc_priv->subbank_depth);
bitmap_weight(bmap, sbd),
bw = bitmap_weight(bmap, npc_priv->subbank_depth);
if (!bitmap_weight(lmac->rx_fc_pfvf_bmap.bmap, lmac->rx_fc_pfvf_bmap.max))
used = bitmap_weight(rsrc->bmap, rsrc->max);
if (bitmap_weight(&w, sz) != sz) {
bitmap_weight(table->mem_table.bmap, table->mem_table.depth));
bitmap_weight(table->cam_table.bmap, table->cam_table.depth));
if (bitmap_weight(req->args.advertising,
if (bitmap_weight(&pfvf->rq_bmap, pfvf->hw.rx_queues) > 1) {
qos_txqs = bitmap_weight(pfvf->qos.qos_sq_bmap,
if (bitmap_weight(flow_cfg->dmacflt_bmap,
qos_txqs = bitmap_weight(pfvf->qos.qos_sq_bmap,
bitmap_weight(port_qos->priority_bm, MLX4_NUM_UP));
unsigned m = bitmap_weight(actv_ports.ports, dev->caps.num_ports);
bitmap_weight(actv_ports.ports, dev->caps.num_ports);
bitmap_weight(actv_ports.ports, priv->dev.caps.num_ports);
h->count = h->advance_array ? bitmap_weight(stats_bitmap, count)
return !!(bitmap_weight(priv->eq_table.eq[vector].actv_ports.ports,
bitmap_weight(actv_ports.ports, dev->caps.num_ports);
field |= bitmap_weight(actv_ports.ports, dev->caps.num_ports) & 0x0F;
bitmap_weight(actv_ports.ports, dev->caps.num_ports),
nvfs = bitmap_weight(slaves_port1.slaves, dev->persist->num_vfs + 1) +
bitmap_weight(slaves_port2.slaves, dev->persist->num_vfs + 1) - 2;
bitmap_weight(actv_ports.ports, dev->caps.num_ports) + 1;
slave_gid -= bitmap_weight(slaves_pport_actv.slaves,
vfs = bitmap_weight(slaves_pport.slaves, dev->persist->num_vfs + 1) - 1;
bitmap_weight(actv_ports.ports, dev->caps.num_ports) + 1;
slave_gid -= bitmap_weight(slaves_pport_actv.slaves,
vfs = bitmap_weight(slaves_pport.slaves, dev->persist->num_vfs + 1) - 1;
num_vfs = bitmap_weight(slaves_pport.slaves,
num_vfs_before += bitmap_weight(
bitmap_weight(actv_ports.ports,
slave_gid += bitmap_weight(
ports = bitmap_weight(actv_ports.ports, dev->caps.num_ports);
bitmap_weight(slaves_pport.slaves,
free_blocks += bitmap_weight(page->bitmap, blocks_per_page);
if (bitmap_weight(&cmd->vars.bitmask, cmd->vars.max_reg_cmds) > 0) {
weight = bitmap_weight(&cmd->vars.bitmask, cmd->vars.max_reg_cmds);
if (bitmap_weight(meters_obj->meters_map, total) == total - 1) {
n = bitmap_weight(meters_obj->meters_map, meters_obj->total_meters);
if (bitmap_weight(&fec_bitmap, ETHTOOL_FEC_LLRS_BIT + 1) > 1)
return bitmap_weight(bulk->bitmask, bulk->bulk_len);
if (bitmap_weight(src_addr->act_tcam,
if (bitmap_weight(&pq_flags,
weight = bitmap_weight(bmap->bitmap, bmap->max_count);
weight = bitmap_weight(bmap->bitmap, bmap->max_count);
weight = bitmap_weight(bmap->bitmap, bmap->max_count);
weight = bitmap_weight(interrupt->suspend_enabled, ipa->endpoint_count);
if (bitmap_weight(ts_mask, 64) != bitmap_weight(map, 64)) {
if (bitmap_weight(ts_mask, 64) != bitmap_weight(map, 64)) {
fft_sample_20.bitmap_weight = bitmap_w;
bitmap_weight(priv->tx.tx_slot, MAX_TX_BUF_NUM));
bitmap_weight(ar->mem_bitmap, ar->fw.mem_blocks),
u8 bitmap_weight;
w->registered_chanctxs = bitmap_weight(hal->entity_map, NUM_OF_RTW89_CHANCTX);
return bitmap_weight(free, nslot);
return bitmap_weight(ccn->dt.pmu_counters_mask,
pmu->name, bitmap_weight(pmu->cntr_mask, ARMPMU_MAX_HWEVENTS),
bit += bitmap_weight(cpu_pmu->cntr_mask, ARMV7_IDX_COUNTER_MAX);
bit += bitmap_weight(cpu_pmu->cntr_mask, ARMV7_IDX_COUNTER_MAX);
if (bitmap_weight(noc_pmu->pmu_events.used_mask, noc_pmu->num_counters) > 1)
if (bitmap_weight(tx2_pmu->active_counters,
npins = bitmap_weight(used_pins, zynqmp_desc.npins);
temp_count = bitmap_weight(priv->temp_sensors, AWCC_ID_BITMAP_SIZE);
rp->nr_domains = bitmap_weight(&rp->domain_map, RAPL_DOMAIN_MAX);
cnt = bitmap_weight(&sr, chip->npwm);
requested_events = bitmap_weight(&lpc18xx_pwm->event_map,
if (bitmap_weight(pca->pwms_enabled, PCA9685_MAXCHAN + 1) > 1)
if (bitmap_weight(&ccmr, sizeof(u32) * BITS_PER_BYTE) > 1)
int scan_count = bitmap_weight(indio_dev->active_scan_mask,
if (f->index >= bitmap_weight(fmts_bitmap, MAX_FORMAT_NUM))
return thresh - bitmap_weight(bitmap, thresh);
ASSERT(bitmap_weight(&rbio->dbitmap, rbio->stripe_nsectors));
ASSERT(bitmap_weight(rbio->error_bitmap, rbio->nr_sectors));
bitmap_weight(&error_bitmap, stripe->nr_sectors);
return bitmap_weight(&bitmap, stripe->nr_sectors); \
const unsigned int nbits = bitmap_weight(bitmap, blocks_per_folio);
count = bitmap_weight(bits, 2048 * BITS_PER_BYTE);
nr_used = bitmap_weight(kaddr, PAGE_SIZE * BITS_PER_BYTE);
nr_free -= bitmap_weight(kaddr,
if (bitmap_weight(o2hb_region_bitmap, O2NM_MAX_REGIONS) == 1)
if (bitmap_weight(o2hb_quorum_region_bitmap,
if (bitmap_weight(o2hb_quorum_region_bitmap,
failed = bitmap_weight(o2hb_failed_region_bitmap,
quorum = bitmap_weight(o2hb_quorum_region_bitmap,
if (bitmap_weight(o2hb_quorum_region_bitmap,
sum += nbits - bitmap_weight(sbi->s_imap[i], nbits);
*count = bitmap_weight(fdt->open_fds, fdt->max_fds);
num_b = bitmap_weight(&cbm, r->cache.cbm_len);
if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) {
accum += bitmap_weight((const unsigned long *)(ptr + index),
w = bitmap_weight(bitmap, end);
return bitmap_weight(cpumask_bits(srcp), small_cpumask_bits);
return bitmap_weight(bitmap, NUM_VMA_FLAG_BITS);
return bitmap_weight(srcp->bits, nbits);
return bitmap_weight(intf, PHY_INTERFACE_MODE_MAX);
return bitmap_weight(q->bufs_bitmap, q->max_num_buffers);
unsigned int nsys = bitmap_weight(m->system_map, m->matrix_bits);
return bitmap_weight(lock_chains_in_use, ARRAY_SIZE(lock_chains));
nr_levels = bitmap_weight(distance_map, NR_DISTANCE_VALUES);
lonely = bitmap_weight(&active, BIT_CNT) <= 1;
return bitmap_weight(&active, BIT_CNT) <= 1;
return bitmap_weight(buf, pos);
w = bitmap_weight(new, nbits);
int w = bitmap_weight(new, bits);
int w = bitmap_weight(addr, size);
unsigned long l, n, w = bitmap_weight(bitmap, len);
ret += bitmap_weight((unsigned long *)bitmap,
weight += bitmap_weight(&word->word, word_depth);
weight += bitmap_weight(&word->cleared, word_depth);
res = bitmap_weight(bitmap, 20);
ret = bitmap_weight(NULL, 0);
expect_eq_uint(bitmap_weight(bmap, 1000), 0);
w = bitmap_weight(b, 30);
w1 = bitmap_weight(b, 15);
w = bitmap_weight(exp1, EXP1_IN_BITS);
w1 = bitmap_weight(exp1, bit);
expect_eq_uint(30, bitmap_weight(b1, 30));
expect_eq_uint(100, bitmap_weight(b1, 100));
expect_eq_uint(i, bitmap_weight(b1, i));
packet_count = bitmap_weight(bitmap,
*weight = bitmap_weight(orig_ifinfo->bat_iv.bcast_own,
*w = bitmap_weight(word,
n_queue = bitmap_weight(queue_mask, MAX_NUM_QUEUE);
pending_data -= bitmap_weight(map->tsn_map, gap + 1);
int num = bitmap_weight(set, c2c.cpus_cnt);
scnprintf(buf, 10, "%d", bitmap_weight(c2c_he->cpuset, c2c.cpus_cnt));
int cpus_nr = bitmap_weight(stat->all_cpus_bitmap, MAX_NR_CPUS);
thread_data->nr_mmaps = bitmap_weight(thread_data->mask->maps.bits,
cpus_nr = bitmap_weight(sched->map.comp_cpus_mask, MAX_CPUS);
weight += bitmap_weight(local_copy, 64);
size = bsize * bitmap_weight(n->set, n->size);
nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
max += bitmap_weight(n->set, n->size);
w = bitmap_weight(format, PERF_PMU_FORMAT_BITS);
bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
num_bits = bits ? bitmap_weight(bits, PERF_PMU_FORMAT_BITS) : 0;
return bitmap_weight(bitmap, NUM_VMA_FLAG_BITS);