/linux-4.1.27/fs/quota/ |
H A D | quotaio_v1.h | 10 * their soft limit, it is reset when they go below their soft limit. 21 __u32 dqb_bhardlimit; /* absolute limit on disk blks alloc */ 22 __u32 dqb_bsoftlimit; /* preferred limit on disk blks */ 24 __u32 dqb_ihardlimit; /* absolute limit on allocated inodes */ 25 __u32 dqb_isoftlimit; /* preferred inode limit */ 27 time_t dqb_btime; /* time limit for excessive disk use */ 28 time_t dqb_itime; /* time limit for excessive inode use */
|
H A D | quotaio_v2.h | 39 __le32 dqb_ihardlimit; /* absolute limit on allocated inodes */ 40 __le32 dqb_isoftlimit; /* preferred inode limit */ 42 __le32 dqb_bhardlimit; /* absolute limit on disk space (in QUOTABLOCK_SIZE) */ 43 __le32 dqb_bsoftlimit; /* preferred limit on disk space (in QUOTABLOCK_SIZE) */ 45 __le64 dqb_btime; /* time limit for excessive disk use */ 46 __le64 dqb_itime; /* time limit for excessive inode use */ 52 __le64 dqb_ihardlimit; /* absolute limit on allocated inodes */ 53 __le64 dqb_isoftlimit; /* preferred inode limit */ 55 __le64 dqb_bhardlimit; /* absolute limit on disk space (in QUOTABLOCK_SIZE) */ 56 __le64 dqb_bsoftlimit; /* preferred limit on disk space (in QUOTABLOCK_SIZE) */ 58 __le64 dqb_btime; /* time limit for excessive disk use */ 59 __le64 dqb_itime; /* time limit for excessive inode use */ 64 __le32 dqi_bgrace; /* Time before block soft limit becomes hard limit */ 65 __le32 dqi_igrace; /* Time before inode soft limit becomes hard limit */
|
/linux-4.1.27/arch/x86/mm/ |
H A D | amdtopology.c | 99 u64 base, limit; amd_numa_init() local 102 limit = read_pci_config(0, nb, 1, 0x44 + i*8); amd_numa_init() 104 nodeids[i] = nodeid = limit & 7; amd_numa_init() 112 base, limit); amd_numa_init() 116 if (!limit) { amd_numa_init() 121 if ((base >> 8) & 3 || (limit >> 8) & 3) { amd_numa_init() 123 nodeid, (base >> 8) & 3, (limit >> 8) & 3); amd_numa_init() 132 limit >>= 16; amd_numa_init() 133 limit++; amd_numa_init() 134 limit <<= 24; amd_numa_init() 136 if (limit > end) amd_numa_init() 137 limit = end; amd_numa_init() 138 if (limit <= base) amd_numa_init() 146 if (limit > end) amd_numa_init() 147 limit = end; amd_numa_init() 148 if (limit == base) { amd_numa_init() 152 if (limit < base) { amd_numa_init() 154 nodeid, base, limit); amd_numa_init() 166 nodeid, base, limit); amd_numa_init() 169 numa_add_memblk(nodeid, base, limit); amd_numa_init()
|
H A D | numa_emulation.c | 129 u64 start, limit, end; for_each_node_mask() local 138 limit = pi->blk[phys_blk].end; for_each_node_mask() 150 if (end > limit) { for_each_node_mask() 151 end = limit; for_each_node_mask() 170 if (limit - end - mem_hole_size(end, limit) < size) for_each_node_mask() 171 end = limit; for_each_node_mask() 175 min(end, limit) - start); for_each_node_mask() 217 * The limit on emulated nodes is MAX_NUMNODES, so the size per node is split_nodes_size_interleave() 244 u64 start, limit, end; for_each_node_mask() local 253 limit = pi->blk[phys_blk].end; for_each_node_mask() 255 end = find_end_of_node(start, limit, size); for_each_node_mask() 270 if (limit - end - mem_hole_size(end, limit) < size) for_each_node_mask() 271 end = limit; for_each_node_mask() 275 min(end, limit) - start); for_each_node_mask()
|
/linux-4.1.27/lib/ |
H A D | dynamic_queue_limits.c | 16 /* Records completed count and recalculates the queue limit */ dql_completed() 19 unsigned int inprogress, prev_inprogress, limit; dql_completed() local 29 limit = dql->limit; dql_completed() 30 ovlimit = POSDIFF(num_queued - dql->num_completed, limit); dql_completed() 39 * - The queue was over-limit in the last interval, dql_completed() 42 * - The queue was over-limit in the previous interval and dql_completed() 48 * When queue is starved increase the limit by the amount dql_completed() 50 * plus any previous over-limit. dql_completed() 52 limit += POSDIFF(completed, dql->prev_num_queued) + dql_completed() 58 * Queue was not starved, check if the limit can be decreased. dql_completed() 63 * the the amount needed to prevent starvation, the queue limit dql_completed() 72 * - The queue limit plus previous over-limit minus twice dql_completed() 75 * of the limit. dql_completed() 77 * was not part of non-zero previous over-limit. That is dql_completed() 81 slack = POSDIFF(limit + dql->prev_ovlimit, dql_completed() 93 limit = POSDIFF(limit, dql->lowest_slack); dql_completed() 99 /* Enforce bounds on limit */ dql_completed() 100 limit = clamp(limit, dql->min_limit, dql->max_limit); dql_completed() 102 if (limit != dql->limit) { dql_completed() 103 dql->limit = limit; dql_completed() 107 dql->adj_limit = limit + completed; dql_completed() 118 dql->limit = 0; dql_reset()
|
H A D | iommu-helper.c | 26 /* We don't want the last of the limit */ iommu_area_alloc()
|
H A D | ratelimit.c | 2 * ratelimit.c - Do something with rate limit. 21 * This enforces a rate limit: not more than @rs->burst callbacks
|
H A D | ucs2_string.c | 86 unsigned long limit = ucs2_strnlen(src, maxlength); ucs2_as_utf8() local 88 for (i = 0; maxlength && i < limit; i++) { ucs2_as_utf8()
|
H A D | iommu-common.c | 109 unsigned long n, end, start, limit, boundary_size; iommu_tbl_range_alloc() local 146 limit = pool->end; iommu_tbl_range_alloc() 154 if (start >= limit) iommu_tbl_range_alloc() 157 if (limit + shift > mask) { iommu_tbl_range_alloc() 158 limit = mask - shift + 1; iommu_tbl_range_alloc() 163 if ((start & mask) >= limit || pass > 0) { iommu_tbl_range_alloc() 189 n = iommu_area_alloc(iommu->map, limit, start, npages, shift, iommu_tbl_range_alloc()
|
H A D | strncpy_from_user.c | 29 * Truncate 'max' to the user-specified limit, so that do_strncpy_from_user() 30 * we only have one limit we need to check in the loop do_strncpy_from_user() 75 * Nope: we hit the address space limit, and we still had more do_strncpy_from_user()
|
H A D | strnlen_user.c | 34 * Truncate 'max' to the user-specified limit, so that do_strnlen_user() 35 * we only have one limit we need to check in the loop do_strnlen_user() 77 * Nope: we hit the address space limit, and we still had more do_strnlen_user() 131 * If there is a limit on the length of a valid string, you may wish to
|
H A D | decompress_bunzip2.c | 82 /* We have an extra slot at the end of limit[] for a sentinal value. */ 83 int limit[MAX_HUFCODE_BITS+1]; member in struct:group_data 159 int *limit = NULL; get_next_block() local 280 /* Calculate permute[], base[], and limit[] tables from get_next_block() 289 * limit[] indicates the largest numerical value a get_next_block() 292 * code with a value > limit[length] needs another get_next_block() 299 adjust the base and limit array pointers so we're get_next_block() 303 limit = hufGroup->limit-1; get_next_block() 305 * temp[] and limit[]. */ get_next_block() 308 temp[i] = limit[i] = 0; get_next_block() 316 /* Calculate limit[] (the largest symbol-coding value get_next_block() 317 *at each bit length, which is (previous limit << get_next_block() 319 *symbols to ignore at each bit length, which is limit get_next_block() 333 affect the value > limit[length] get_next_block() 335 limit[i] = (pp << (maxLen - i)) - 1; get_next_block() 339 limit[maxLen+1] = INT_MAX; /* Sentinal value for get_next_block() 341 limit[maxLen] = pp+temp[maxLen]-1; get_next_block() 365 limit = hufGroup->limit-1; get_next_block() 395 while (j > limit[i]) get_next_block()
|
/linux-4.1.27/net/sched/ |
H A D | sch_fifo.c | 24 if (likely(sch->qstats.backlog + qdisc_pkt_len(skb) <= sch->limit)) bfifo_enqueue() 32 if (likely(skb_queue_len(&sch->q) < sch->limit)) pfifo_enqueue() 40 if (likely(skb_queue_len(&sch->q) < sch->limit)) pfifo_tail_enqueue() 43 /* queue full, remove one skb to fulfill the limit */ pfifo_tail_enqueue() 57 u32 limit = qdisc_dev(sch)->tx_queue_len ? : 1; fifo_init() local 60 limit *= psched_mtu(qdisc_dev(sch)); fifo_init() 62 sch->limit = limit; fifo_init() 69 sch->limit = ctl->limit; fifo_init() 73 bypass = sch->limit >= psched_mtu(qdisc_dev(sch)); fifo_init() 75 bypass = sch->limit >= 1; fifo_init() 86 struct tc_fifo_qopt opt = { .limit = sch->limit }; fifo_dump() 141 int fifo_set_limit(struct Qdisc *q, unsigned int limit) fifo_set_limit() argument 154 ((struct tc_fifo_qopt *)nla_data(nla))->limit = limit; fifo_set_limit() 164 unsigned int limit) fifo_create_dflt() 171 err = fifo_set_limit(q, limit); fifo_create_dflt() 163 fifo_create_dflt(struct Qdisc *sch, struct Qdisc_ops *ops, unsigned int limit) fifo_create_dflt() argument
|
H A D | sch_red.c | 29 limit - bytes (must be > qth_max + burst) 31 Hard limit on queue length, should be chosen >qth_max 35 Really, this limit will never be reached 40 u32 limit; /* HARD maximal queue length */ member in struct:red_sched_data 203 if (ctl->limit > 0) { red_change() 204 child = fifo_create_dflt(sch, &bfifo_qdisc_ops, ctl->limit); red_change() 211 q->limit = ctl->limit; red_change() 262 .limit = q->limit, red_dump()
|
H A D | sch_sfb.c | 65 u32 limit; /* HARD maximal queue length */ member in struct:sfb_sched_data 292 if (unlikely(sch->q.qlen >= q->limit)) { sfb_enqueue() 299 unsigned long limit = q->rehash_time + q->rehash_interval; sfb_enqueue() local 301 if (unlikely(time_after(jiffies, limit))) { sfb_enqueue() 305 time_after(jiffies, limit - q->warmup_time))) { sfb_enqueue() 482 .limit = 0, 497 u32 limit; sfb_change() local 511 limit = ctl->limit; sfb_change() 512 if (limit == 0) sfb_change() 513 limit = max_t(u32, qdisc_dev(sch)->tx_queue_len, 1); sfb_change() 515 child = fifo_create_dflt(sch, &pfifo_qdisc_ops, limit); sfb_change() 528 q->limit = limit; sfb_change() 564 .limit = q->limit, sfb_dump()
|
H A D | sch_plug.c | 68 u32 limit; member in struct:plug_sched_data 93 if (likely(sch->qstats.backlog + skb->len <= q->limit)) { plug_enqueue() 133 /* We will set a default limit of 100 pkts (~150kB) plug_init() 138 q->limit = pkt_limit * psched_mtu(qdisc_dev(sch)); plug_init() 145 q->limit = ctl->limit; plug_init() 202 q->limit = msg->limit; plug_change()
|
H A D | sch_pie.c | 43 u32 limit; /* number of packets that can be enqueued */ member in struct:pie_params 52 u32 prob; /* probability but scaled by u32 limit. */ 84 params->limit = 1000; /* default of 1000 packets */ pie_params_init() 142 if (unlikely(qdisc_qlen(sch) >= sch->limit)) { pie_qdisc_enqueue() 212 u32 limit = nla_get_u32(tb[TCA_PIE_LIMIT]); pie_change() local 214 q->params.limit = limit; pie_change() 215 sch->limit = limit; pie_change() 230 /* Drop excess packets if new limit is lower */ pie_change() 232 while (sch->q.qlen > sch->limit) { pie_change() 445 sch->limit = q->params.limit; pie_init() 473 nla_put_u32(skb, TCA_PIE_LIMIT, sch->limit) || pie_dump()
|
H A D | sch_codel.c | 98 if (likely(qdisc_qlen(sch) < sch->limit)) { codel_qdisc_enqueue() 143 sch->limit = nla_get_u32(tb[TCA_CODEL_LIMIT]); codel_change() 149 while (sch->q.qlen > sch->limit) { codel_change() 165 sch->limit = DEFAULT_CODEL_LIMIT; codel_init() 178 if (sch->limit >= 1) codel_init() 198 sch->limit) || codel_dump()
|
H A D | sch_tbf.c | 96 With classful TBF, limit is just kept for backwards compatibility. 98 changed the limit is not effective anymore. 103 u32 limit; /* Maximal length of backlog: bytes */ member in struct:tbf_sched_data 389 err = fifo_set_limit(q->qdisc, qopt->limit); tbf_change() 392 } else if (qopt->limit > 0) { tbf_change() 393 child = fifo_create_dflt(sch, &bfifo_qdisc_ops, qopt->limit); tbf_change() 406 q->limit = qopt->limit; tbf_change() 461 opt.limit = q->limit; tbf_dump()
|
H A D | sch_sfq.c | 119 int limit; /* limit of total number of packets in this qdisc */ member in struct:sfq_sched_data 122 u8 maxdepth; /* limit of packets per flow */ 483 if (++sch->q.qlen <= q->limit) sfq_enqueue() 686 if (ctl->limit) { sfq_change() 687 q->limit = min_t(u32, ctl->limit, q->maxdepth * q->maxflows); sfq_change() 688 q->maxflows = min_t(u32, q->maxflows, q->limit); sfq_change() 692 while (sch->q.qlen > q->limit) sfq_change() 746 q->limit = SFQ_MAX_DEPTH; sfq_init() 776 if (q->limit >= 1) sfq_init() 793 opt.v0.limit = q->limit; sfq_dump()
|
H A D | sch_choke.c | 53 u32 limit; member in struct:choke_sched_data 331 if (sch->q.qlen < q->limit) { choke_enqueue() 434 if (ctl->limit > CHOKE_MAX_QUEUE) choke_change() 437 mask = roundup_pow_of_two(ctl->limit + 1) - 1; choke_change() 478 q->limit = ctl->limit; choke_change() 504 .limit = q->limit, choke_dump()
|
/linux-4.1.27/drivers/sbus/char/ |
H A D | max1617.h | 12 #define MAX1617_RD_AMB_HIGHLIM 0x05 /* Ambient high limit */ 13 #define MAX1617_RD_AMB_LOWLIM 0x06 /* Ambient low limit */ 14 #define MAX1617_RD_CPU_HIGHLIM 0x07 /* Processor high limit */ 15 #define MAX1617_RD_CPU_LOWLIM 0x08 /* Processor low limit */
|
/linux-4.1.27/include/uapi/linux/netfilter_bridge/ |
H A D | ebt_limit.h | 6 #define EBT_LIMIT_MATCH "limit" 16 __u32 burst; /* Period multiplier for upper limit. */
|
/linux-4.1.27/arch/arm64/lib/ |
H A D | memcmp.S | 43 limit .req x2 label 62 cbz limit, .Lret0 68 sub limit_wd, limit, #1 /* limit != 0, so no underflow. */ 83 /* Not reached the limit, must have found a diff. */ 87 ands limit, limit, #7 93 lsl limit, limit, #3 /* bytes-> bits. */ 95 CPU_BE( lsr mask, mask, limit ) 96 CPU_LE( lsl mask, mask, limit ) 114 * We can not add limit with alignment offset(tmp1) here. Since the 115 * addition probably make the limit overflown. 117 sub limit_wd, limit, #1/*limit != 0, so no underflow.*/ 122 add limit, limit, tmp1/* Adjust the limit for the extra. */ 138 cmp limit, #8 139 b.lo .Ltiny8proc /*limit < 8: compare byte by byte*/ 150 sub limit, limit, pos 166 lsr limit_wd, limit, #3 174 sub limit, limit, tmp3 175 lsr limit_wd, limit, #3 243 ands limit, limit, #7 249 subs limit, limit, #1
|
H A D | strncmp.S | 47 limit .req x2 label 68 cbz limit, .Lret0 77 * when limit is mulitply of 8, if not sub 1, 80 sub limit_wd, limit, #1 /* limit != 0, so no underflow. */ 101 /*Not reached the limit, must have found the end or a diff. */ 105 ands limit, limit, #7 108 lsl limit, limit, #3 /* Bits -> bytes. */ 110 CPU_BE( lsr mask, mask, limit ) 111 CPU_LE( lsl mask, mask, limit ) 127 * We also need to adjust the limit calculations, but without 128 * overflowing if the limit is near ULONG_MAX. 136 sub limit_wd, limit, #1 /* limit != 0, so no underflow. */ 144 /* Adjust the limit. Only low 3 bits used, so overflow irrelevant.*/ 145 add limit, limit, tmp1 154 cmp limit, #8 155 b.lo .Ltiny8proc /*limit < 8... */ 168 * Here, limit is not less than 8, so directly run .Ltinycmp 169 * without checking the limit.*/ 170 sub limit, limit, pos 187 lsr limit_wd, limit, #3 197 sub limit, limit, tmp3 198 lsr limit_wd, limit, #3 294 ands limit, limit, #7 299 subs limit, limit, #1
|
H A D | strnlen.S | 41 limit .req x1 label 63 cbz limit, .Lhit_limit 69 sub limit_wd, limit, #1 /* Limit != 0, so no underflow. */ 102 * MIN (len, limit). 126 cmp len, limit 127 csel len, len, limit, ls /* Return the lower value. */ 135 * limit is near ULONG_MAX) - to do this we need to work out 136 * limit + tmp1 - 1 as a 65-bit value before shifting it; 143 sub limit_wd, limit, #1 169 mov len, limit
|
/linux-4.1.27/drivers/net/ethernet/stmicro/stmmac/ |
H A D | stmmac_hwtstamp.c | 56 int limit; stmmac_init_systime() local 67 limit = 10; stmmac_init_systime() 68 while (limit--) { stmmac_init_systime() 73 if (limit < 0) stmmac_init_systime() 82 int limit; stmmac_config_addend() local 91 limit = 10; stmmac_config_addend() 92 while (limit--) { stmmac_config_addend() 97 if (limit < 0) stmmac_config_addend() 107 int limit; stmmac_adjust_systime() local 118 limit = 10; stmmac_adjust_systime() 119 while (limit--) { stmmac_adjust_systime() 124 if (limit < 0) stmmac_adjust_systime()
|
H A D | dwmac100_dma.c | 39 int limit; dwmac100_dma_init() local 44 limit = 10; dwmac100_dma_init() 45 while (limit--) { dwmac100_dma_init() 50 if (limit < 0) dwmac100_dma_init()
|
H A D | dwmac1000_dma.c | 37 int limit; dwmac1000_dma_init() local 42 limit = 10; dwmac1000_dma_init() 43 while (limit--) { dwmac1000_dma_init() 48 if (limit < 0) dwmac1000_dma_init()
|
/linux-4.1.27/arch/tile/lib/ |
H A D | uaccess.c | 20 unsigned long limit = current_thread_info()->addr_limit.seg; __range_ok() local 21 return !((addr < limit && size <= limit - addr) || __range_ok()
|
/linux-4.1.27/mm/ |
H A D | page_counter.c | 57 * @fail: points first counter to hit its limit, if any 60 * its ancestors has hit its configured limit. 80 * the limit. When racing with page_counter_limit(), page_counter_try_charge() 81 * we either see the new limit or the setter sees the page_counter_try_charge() 85 if (new > c->limit) { page_counter_try_charge() 125 * page_counter_limit - limit the number of pages allowed 127 * @limit: limit to set 130 * counter already exceeds the specified limit. 134 int page_counter_limit(struct page_counter *counter, unsigned long limit) page_counter_limit() argument 141 * Update the limit while making sure that it's not page_counter_limit() 148 * the limit, so if it sees the old limit, we see the page_counter_limit() 153 if (count > limit) page_counter_limit() 156 old = xchg(&counter->limit, limit); page_counter_limit() 161 counter->limit = old; page_counter_limit()
|
H A D | nobootmem.c | 36 u64 goal, u64 limit) __alloc_memory_core_early() 41 if (limit > memblock.current_limit) __alloc_memory_core_early() 42 limit = memblock.current_limit; __alloc_memory_core_early() 44 addr = memblock_find_in_range_node(size, align, goal, limit, nid); __alloc_memory_core_early() 224 unsigned long limit) ___alloc_bootmem_nopanic() 233 ptr = __alloc_memory_core_early(NUMA_NO_NODE, size, align, goal, limit); ___alloc_bootmem_nopanic() 262 unsigned long limit = -1UL; __alloc_bootmem_nopanic() local 264 return ___alloc_bootmem_nopanic(size, align, goal, limit); __alloc_bootmem_nopanic() 268 unsigned long goal, unsigned long limit) ___alloc_bootmem() 270 void *mem = ___alloc_bootmem_nopanic(size, align, goal, limit); ___alloc_bootmem() 298 unsigned long limit = -1UL; __alloc_bootmem() local 300 return ___alloc_bootmem(size, align, goal, limit); __alloc_bootmem() 307 unsigned long limit) ___alloc_bootmem_node_nopanic() 313 goal, limit); ___alloc_bootmem_node_nopanic() 318 goal, limit); ___alloc_bootmem_node_nopanic() 341 unsigned long limit) ___alloc_bootmem_node() 345 ptr = ___alloc_bootmem_node_nopanic(pgdat, size, align, goal, limit); ___alloc_bootmem_node() 35 __alloc_memory_core_early(int nid, u64 size, u64 align, u64 goal, u64 limit) __alloc_memory_core_early() argument 221 ___alloc_bootmem_nopanic(unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem_nopanic() argument 267 ___alloc_bootmem(unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem() argument 303 ___alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem_node_nopanic() argument 339 ___alloc_bootmem_node(pg_data_t *pgdat, unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem_node() argument
|
H A D | bootmem.c | 495 unsigned long goal, unsigned long limit) alloc_bootmem_bdata() 500 bdebug("nid=%td size=%lx [%lu pages] align=%lx goal=%lx limit=%lx\n", alloc_bootmem_bdata() 502 align, goal, limit); alloc_bootmem_bdata() 506 BUG_ON(limit && goal + size > limit); alloc_bootmem_bdata() 515 limit >>= PAGE_SHIFT; alloc_bootmem_bdata() 517 if (limit && max > limit) alloc_bootmem_bdata() 518 max = limit; alloc_bootmem_bdata() 603 unsigned long limit) alloc_bootmem_core() 614 if (limit && bdata->node_min_pfn >= PFN_DOWN(limit)) alloc_bootmem_core() 617 region = alloc_bootmem_bdata(bdata, size, align, goal, limit); alloc_bootmem_core() 628 unsigned long limit) ___alloc_bootmem_nopanic() 633 ptr = alloc_bootmem_core(size, align, goal, limit); ___alloc_bootmem_nopanic() 660 unsigned long limit = 0; __alloc_bootmem_nopanic() local 662 return ___alloc_bootmem_nopanic(size, align, goal, limit); __alloc_bootmem_nopanic() 666 unsigned long goal, unsigned long limit) ___alloc_bootmem() 668 void *mem = ___alloc_bootmem_nopanic(size, align, goal, limit); ___alloc_bootmem() 696 unsigned long limit = 0; __alloc_bootmem() local 698 return ___alloc_bootmem(size, align, goal, limit); __alloc_bootmem() 703 unsigned long goal, unsigned long limit) ___alloc_bootmem_node_nopanic() 712 if (limit && goal + size > limit) ___alloc_bootmem_node_nopanic() 713 limit = 0; ___alloc_bootmem_node_nopanic() 715 ptr = alloc_bootmem_bdata(pgdat->bdata, size, align, goal, limit); ___alloc_bootmem_node_nopanic() 719 ptr = alloc_bootmem_core(size, align, goal, limit); ___alloc_bootmem_node_nopanic() 742 unsigned long limit) ___alloc_bootmem_node() 493 alloc_bootmem_bdata(struct bootmem_data *bdata, unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) alloc_bootmem_bdata() argument 600 alloc_bootmem_core(unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) alloc_bootmem_core() argument 625 ___alloc_bootmem_nopanic(unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem_nopanic() argument 665 ___alloc_bootmem(unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem() argument 701 ___alloc_bootmem_node_nopanic(pg_data_t *pgdat, unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem_node_nopanic() argument 740 ___alloc_bootmem_node(pg_data_t *pgdat, unsigned long size, unsigned long align, unsigned long goal, unsigned long limit) ___alloc_bootmem_node() argument
|
H A D | cma.c | 214 * @limit: End address of the reserved memory (optional, 0 for any). 226 * reserve in range from @base to @limit. 229 phys_addr_t size, phys_addr_t limit, cma_declare_contiguous() 249 pr_debug("%s(size %pa, base %pa, limit %pa alignment %pa)\n", cma_declare_contiguous() 250 __func__, &size, &base, &limit, &alignment); cma_declare_contiguous() 273 limit &= ~(alignment - 1); cma_declare_contiguous() 294 * If the limit is unspecified or above the memblock end, its effective cma_declare_contiguous() 298 if (limit == 0 || limit > memblock_end) cma_declare_contiguous() 299 limit = memblock_end; cma_declare_contiguous() 317 if (base < highmem_start && limit > highmem_start) { cma_declare_contiguous() 319 highmem_start, limit); cma_declare_contiguous() 320 limit = highmem_start; cma_declare_contiguous() 325 limit); cma_declare_contiguous() 228 cma_declare_contiguous(phys_addr_t base, phys_addr_t size, phys_addr_t limit, phys_addr_t alignment, unsigned int order_per_bit, bool fixed, struct cma **res_cma) cma_declare_contiguous() argument
|
/linux-4.1.27/include/uapi/linux/netfilter/ipset/ |
H A D | ip_set_bitmap.h | 8 /* The range exceeds the size limit of the set type */
|
/linux-4.1.27/arch/ia64/include/asm/ |
H A D | ustack.h | 7 /* The absolute hard limit for stack size is 1/2 of the mappable space in the region */
|
H A D | mmu_context.h | 37 unsigned int limit; /* available free range */ member in struct:ia64_ctx 91 if (ia64_ctx.next >= ia64_ctx.limit) { get_mmu_context() 94 ia64_ctx.limit = find_next_bit(ia64_ctx.bitmap, get_mmu_context()
|
/linux-4.1.27/include/uapi/linux/ |
H A D | ip6_tunnel.h | 9 /* don't add encapsulation limit if one isn't present in inner packet */ 26 __u8 encap_limit; /* encapsulation limit for tunnel */ 27 __u8 hop_limit; /* hop limit for tunnel */ 38 __u8 encap_limit; /* encapsulation limit for tunnel */ 39 __u8 hop_limit; /* hop limit for tunnel */
|
H A D | dqblk_xfs.h | 56 __u64 d_blk_hardlimit;/* absolute limit on disk blks */ 57 __u64 d_blk_softlimit;/* preferred limit on disk blks */ 59 __u64 d_ino_softlimit;/* preferred inode limit */ 68 __u64 d_rtb_hardlimit;/* absolute limit on realtime blks */ 69 __u64 d_rtb_softlimit;/* preferred limit on RT disk blks */ 103 * below the soft limit). Superusers warning values set the warning limits 160 __s32 qs_btimelimit; /* limit for blks timer */ 161 __s32 qs_itimelimit; /* limit for inodes timer */ 162 __s32 qs_rtbtimelimit;/* limit for rt blks timer */ 163 __u16 qs_bwarnlimit; /* limit for num warnings */ 164 __u16 qs_iwarnlimit; /* limit for num warnings */ 205 __s32 qs_btimelimit; /* limit for blks timer */ 206 __s32 qs_itimelimit; /* limit for inodes timer */ 207 __s32 qs_rtbtimelimit;/* limit for rt blks timer */ 208 __u16 qs_bwarnlimit; /* limit for num warnings */ 209 __u16 qs_iwarnlimit; /* limit for num warnings */
|
H A D | msg.h | 57 * MSGMNI is the upper limit for the number of messages queues per 61 * operations of the form retrieve current limit; add X; update limit". 70 * (per-namespace) limit that applies for all message queues.
|
H A D | pkt_sched.h | 82 #define TC_LINKLAYER_MASK 0x0F /* limit use to lower 4 bits */ 118 __u32 limit; /* Queue length: bytes for bfifo, packets for pfifo */ member in struct:tc_fifo_qopt 156 __u32 limit; member in struct:tc_plug_qopt 164 __u32 limit; member in struct:tc_tbf_qopt 193 __u32 limit; /* Maximal packets in queue */ member in struct:tc_sfq_qopt 212 __u32 limit; /* HARD maximal flow queue length (bytes) */ member in struct:tc_sfq_qopt_v1 242 __u32 limit; /* HARD maximal queue length (bytes) */ member in struct:tc_red_qopt 277 __u32 limit; /* HARD maximal queue length (bytes) */ member in struct:tc_gred_qopt 317 __u32 limit; /* Hard queue length (packets) */ member in struct:tc_choke_qopt 536 __u32 limit; /* fifo limit (packets) */ member in struct:tc_netem_qopt 640 __u32 limit; /* max SFB queue length */ member in struct:tc_sfb_qopt 695 __u32 drop_overlimit; /* number of time max qdisc packet limit was hit */ 723 * packet limit was hit 759 TCA_FQ_PLIMIT, /* limit of total number of packets in queue */ 761 TCA_FQ_FLOW_PLIMIT, /* limit of packets per flow */ 816 __u32 drop_overlimit; /* number of times max qdisc packet limit
|
H A D | gen_stats.h | 57 * @overlimits: number of enqueues over the limit
|
H A D | posix_types.h | 10 * one limit that doesn't have to be changed [again].
|
H A D | shm.h | 15 * "retrieve current limit; add X; update limit". It is therefore not
|
H A D | falloc.h | 19 * granularity of the operation. Most will limit operations to 51 * of the operation. Most will limit operations to filesystem block size
|
/linux-4.1.27/net/netfilter/ |
H A D | nf_conntrack_sip.c | 59 const char *limit, int *shift) string_len() 63 while (dptr < limit && isalpha(*dptr)) { string_len() 71 const char *limit, int *shift) digits_len() 74 while (dptr < limit && isdigit(*dptr)) { digits_len() 91 static int word_len(const char *dptr, const char *limit) word_len() argument 94 while (dptr < limit && iswordc(*dptr)) { word_len() 102 const char *limit, int *shift) callid_len() 106 len = word_len(dptr, limit); callid_len() 108 if (!len || dptr == limit || *dptr != '@') callid_len() 113 domain_len = word_len(dptr, limit); callid_len() 121 const char *limit, int *shift) media_len() 123 int len = string_len(ct, dptr, limit, shift); media_len() 126 if (dptr >= limit || *dptr != ' ') media_len() 131 return len + digits_len(ct, dptr, limit, shift); media_len() 136 const char *limit, bool delim) sip_parse_addr() 147 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end); sip_parse_addr() 152 if (cp < limit && *cp == '[') sip_parse_addr() 157 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end); sip_parse_addr() 161 if (end < limit && *end == ']') sip_parse_addr() 177 const char *limit, int *shift) epaddr_len() 182 if (!sip_parse_addr(ct, dptr, &dptr, &addr, limit, true)) { epaddr_len() 190 dptr += digits_len(ct, dptr, limit, shift); epaddr_len() 197 const char *limit, int *shift) skp_epaddr_len() 205 while (dptr < limit && skp_epaddr_len() 211 if (dptr < limit && *dptr == '@') { skp_epaddr_len() 219 return epaddr_len(ct, dptr, limit, shift); skp_epaddr_len() 233 const char *start = dptr, *limit = dptr + datalen, *end; ct_sip_parse_request() local 239 mlen = string_len(ct, dptr, limit, NULL); ct_sip_parse_request() 243 if (++dptr >= limit) ct_sip_parse_request() 247 for (; dptr < limit - strlen("sip:"); dptr++) { ct_sip_parse_request() 255 if (!skp_epaddr_len(ct, dptr, limit, &shift)) ct_sip_parse_request() 259 if (!sip_parse_addr(ct, dptr, &end, addr, limit, true)) ct_sip_parse_request() 261 if (end < limit && *end == ':') { ct_sip_parse_request() 303 static const char *sip_follow_continuation(const char *dptr, const char *limit) sip_follow_continuation() argument 306 if (++dptr >= limit) sip_follow_continuation() 311 if (++dptr >= limit) sip_follow_continuation() 320 for (; dptr < limit; dptr++) { sip_follow_continuation() 327 static const char *sip_skip_whitespace(const char *dptr, const char *limit) sip_skip_whitespace() argument 329 for (; dptr < limit; dptr++) { sip_skip_whitespace() 334 dptr = sip_follow_continuation(dptr, limit); sip_skip_whitespace() 342 static const char *ct_sip_header_search(const char *dptr, const char *limit, ct_sip_header_search() argument 345 for (limit -= len; dptr < limit; dptr++) { ct_sip_header_search() 347 dptr = sip_follow_continuation(dptr, limit); ct_sip_header_search() 365 const char *start = dptr, *limit = dptr + datalen; ct_sip_get_header() local 368 for (dptr += dataoff; dptr < limit; dptr++) { ct_sip_get_header() 372 if (++dptr >= limit) ct_sip_get_header() 375 if (++dptr >= limit) ct_sip_get_header() 385 if (limit - dptr >= hdr->len && ct_sip_get_header() 388 else if (hdr->cname && limit - dptr >= hdr->clen + 1 && ct_sip_get_header() 396 dptr = sip_skip_whitespace(dptr, limit); ct_sip_get_header() 399 if (*dptr != ':' || ++dptr >= limit) ct_sip_get_header() 403 dptr = sip_skip_whitespace(dptr, limit); ct_sip_get_header() 409 dptr = ct_sip_header_search(dptr, limit, hdr->search, ct_sip_get_header() 416 *matchlen = hdr->match_len(ct, dptr, limit, &shift); ct_sip_get_header() 433 const char *start = dptr, *limit = dptr + datalen; ct_sip_next_header() local 438 dptr = ct_sip_header_search(dptr, limit, ",", strlen(",")); ct_sip_next_header() 442 dptr = ct_sip_header_search(dptr, limit, hdr->search, hdr->slen); ct_sip_next_header() 448 *matchlen = hdr->match_len(ct, dptr, limit, &shift); ct_sip_next_header() 503 const char *c, *limit = dptr + datalen; ct_sip_parse_header_uri() local 513 if (!sip_parse_addr(ct, dptr + *matchoff, &c, addr, limit, true)) ct_sip_parse_header_uri() 535 const char *limit = dptr + datalen; ct_sip_parse_param() local 539 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(",")); ct_sip_parse_param() 540 if (!limit) ct_sip_parse_param() 541 limit = dptr + datalen; ct_sip_parse_param() 543 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name)); ct_sip_parse_param() 548 end = ct_sip_header_search(start, limit, ";", strlen(";")); ct_sip_parse_param() 550 end = limit; ct_sip_parse_param() 564 const char *limit = dptr + datalen; ct_sip_parse_address_param() local 567 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(",")); ct_sip_parse_address_param() 568 if (!limit) ct_sip_parse_address_param() 569 limit = dptr + datalen; ct_sip_parse_address_param() 571 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name)); ct_sip_parse_address_param() 576 if (!sip_parse_addr(ct, start, &end, addr, limit, delim)) ct_sip_parse_address_param() 591 const char *limit = dptr + datalen; ct_sip_parse_numerical_param() local 595 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(",")); ct_sip_parse_numerical_param() 596 if (!limit) ct_sip_parse_numerical_param() 597 limit = dptr + datalen; ct_sip_parse_numerical_param() 599 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name)); ct_sip_parse_numerical_param() 640 const char *limit) sdp_parse_addr() 648 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end); sdp_parse_addr() 651 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end); sdp_parse_addr() 666 const char *limit, int *shift) sdp_addr_len() 671 if (!sdp_parse_addr(ct, dptr, &dptr, &addr, limit)) { sdp_addr_len() 703 static const char *ct_sdp_header_search(const char *dptr, const char *limit, ct_sdp_header_search() argument 706 for (limit -= len; dptr < limit; dptr++) { ct_sdp_header_search() 726 const char *start = dptr, *limit = dptr + datalen; ct_sip_get_sdp_header() local 733 for (dptr += dataoff; dptr < limit; dptr++) { ct_sip_get_sdp_header() 737 if (++dptr >= limit) ct_sip_get_sdp_header() 740 if (++dptr >= limit) ct_sip_get_sdp_header() 745 limit - dptr >= thdr->len && ct_sip_get_sdp_header() 748 else if (limit - dptr >= hdr->len && ct_sip_get_sdp_header() 756 dptr = ct_sdp_header_search(dptr, limit, hdr->search, ct_sip_get_sdp_header() 763 *matchlen = hdr->match_len(ct, dptr, limit, &shift); ct_sip_get_sdp_header() 58 string_len(const struct nf_conn *ct, const char *dptr, const char *limit, int *shift) string_len() argument 70 digits_len(const struct nf_conn *ct, const char *dptr, const char *limit, int *shift) digits_len() argument 101 callid_len(const struct nf_conn *ct, const char *dptr, const char *limit, int *shift) callid_len() argument 120 media_len(const struct nf_conn *ct, const char *dptr, const char *limit, int *shift) media_len() argument 134 sip_parse_addr(const struct nf_conn *ct, const char *cp, const char **endp, union nf_inet_addr *addr, const char *limit, bool delim) sip_parse_addr() argument 176 epaddr_len(const struct nf_conn *ct, const char *dptr, const char *limit, int *shift) epaddr_len() argument 196 skp_epaddr_len(const struct nf_conn *ct, const char *dptr, const char *limit, int *shift) skp_epaddr_len() argument 638 sdp_parse_addr(const struct nf_conn *ct, const char *cp, const char **endp, union nf_inet_addr *addr, const char *limit) sdp_parse_addr() argument 665 sdp_addr_len(const struct nf_conn *ct, const char *dptr, const char *limit, int *shift) sdp_addr_len() argument
|
H A D | nft_limit.c | 97 .name = "limit", 120 MODULE_ALIAS_NFT_EXPR("limit");
|
/linux-4.1.27/arch/x86/um/asm/ |
H A D | mm_context.h | 38 ((((info)->base_addr & 0x0000ffff) << 16) | ((info)->limit & 0x0ffff)) 43 ((info)->limit & 0xf0000) | \ 54 (info)->limit == 0 && \
|
H A D | desc.h | 8 (info)->limit == 0 && \
|
/linux-4.1.27/fs/xfs/ |
H A D | xfs_qm.h | 70 time_t qi_btimelimit; /* limit for blks timer */ 71 time_t qi_itimelimit; /* limit for inodes timer */ 72 time_t qi_rtbtimelimit;/* limit for rt blks timer */ 73 xfs_qwarncnt_t qi_bwarnlimit; /* limit for blks warnings */ 74 xfs_qwarncnt_t qi_iwarnlimit; /* limit for inodes warnings */ 75 xfs_qwarncnt_t qi_rtbwarnlimit;/* limit for rt blks warnings */ 79 xfs_qcnt_t qi_bhardlimit; /* default data blk hard limit */ 80 xfs_qcnt_t qi_bsoftlimit; /* default data blk soft limit */ 81 xfs_qcnt_t qi_ihardlimit; /* default inode count hard limit */ 82 xfs_qcnt_t qi_isoftlimit; /* default inode count soft limit */ 83 xfs_qcnt_t qi_rtbhardlimit;/* default realtime blk hard limit */ 84 xfs_qcnt_t qi_rtbsoftlimit;/* default realtime blk soft limit */
|
H A D | xfs_qm_bhv.c | 36 __uint64_t limit; xfs_fill_statvfs_from_dquot() local 38 limit = dqp->q_core.d_blk_softlimit ? xfs_fill_statvfs_from_dquot() 41 if (limit && statp->f_blocks > limit) { xfs_fill_statvfs_from_dquot() 42 statp->f_blocks = limit; xfs_fill_statvfs_from_dquot() 48 limit = dqp->q_core.d_ino_softlimit ? xfs_fill_statvfs_from_dquot() 51 if (limit && statp->f_files > limit) { xfs_fill_statvfs_from_dquot() 52 statp->f_files = limit; xfs_fill_statvfs_from_dquot()
|
H A D | xfs_pnfs.c | 124 loff_t limit; xfs_fs_map_blocks() local 151 limit = mp->m_super->s_maxbytes; xfs_fs_map_blocks() 153 limit = max(limit, round_up(i_size_read(inode), xfs_fs_map_blocks() 155 if (offset > limit) xfs_fs_map_blocks() 157 if (offset > limit - length) xfs_fs_map_blocks() 158 length = limit - offset; xfs_fs_map_blocks()
|
/linux-4.1.27/include/linux/ |
H A D | page_counter.h | 10 unsigned long limit; member in struct:page_counter 28 counter->limit = PAGE_COUNTER_MAX; page_counter_init() 43 int page_counter_limit(struct page_counter *counter, unsigned long limit);
|
H A D | dynamic_queue_limits.h | 10 * 1) Objects are queued up to some limit specified as number of objects. 13 * 3) Starvation occurs when limit has been reached, all queued data has 18 * The goal of dql is to calculate the limit as the minimum number of objects 24 * on the object limit and how many objects are already enqueued 43 unsigned int adj_limit; /* limit + num_completed */ 48 unsigned int limit ____cacheline_aligned_in_smp; /* Current limit */ 51 unsigned int prev_ovlimit; /* Previous over limit */ 59 unsigned int max_limit; /* Max limit */ 60 unsigned int min_limit; /* Minimum limit */ 88 /* Returns how many objects can be queued, < 0 indicates over limit. */ dql_avail() 94 /* Record number of completed objects and recalculate the limit. */
|
H A D | acpi_pmtmr.h | 9 /* limit it to 24 bits */
|
H A D | ipc.h | 8 #define IPCMNI 32768 /* <= MAX_INT limit for ipc arrays (including sysctl changes) */
|
H A D | dma-contiguous.h | 86 phys_addr_t limit, struct cma **res_cma, 95 * @limit: End address of the reserved memory (optional, 0 for any). 103 phys_addr_t base, phys_addr_t limit) dma_declare_contiguous() 107 ret = dma_contiguous_reserve_area(size, base, limit, &cma, true); dma_declare_contiguous() 130 static inline void dma_contiguous_reserve(phys_addr_t limit) { } dma_contiguous_reserve() argument 133 phys_addr_t limit, struct cma **res_cma, dma_contiguous_reserve_area() 141 phys_addr_t base, phys_addr_t limit) dma_declare_contiguous() 102 dma_declare_contiguous(struct device *dev, phys_addr_t size, phys_addr_t base, phys_addr_t limit) dma_declare_contiguous() argument 132 dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base, phys_addr_t limit, struct cma **res_cma, bool fixed) dma_contiguous_reserve_area() argument 140 dma_declare_contiguous(struct device *dev, phys_addr_t size, phys_addr_t base, phys_addr_t limit) dma_declare_contiguous() argument
|
H A D | cma.h | 23 phys_addr_t size, phys_addr_t limit,
|
H A D | threads.h | 6 * The default limit for the nr of threads is now in
|
H A D | tty_flip.h | 4 extern int tty_buffer_set_limit(struct tty_port *port, int limit);
|
H A D | quota.h | 196 qsize_t dqb_bhardlimit; /* absolute limit on disk blks alloc */ 197 qsize_t dqb_bsoftlimit; /* preferred limit on disk blks */ 200 qsize_t dqb_ihardlimit; /* absolute limit on allocated inodes */ 201 qsize_t dqb_isoftlimit; /* preferred inode limit */ 203 time_t dqb_btime; /* time limit for excessive disk use */ 204 time_t dqb_itime; /* time limit for excessive inode use */ 274 #define DQ_BLKS_B 1 /* uid/gid has been warned about blk limit */ 275 #define DQ_INODES_B 2 /* uid/gid has been warned about inode limit */ 331 u64 d_spc_hardlimit; /* absolute limit on used space */ 332 u64 d_spc_softlimit; /* preferred limit on used space */ 334 u64 d_ino_softlimit; /* preferred inode limit */ 342 u64 d_rt_spc_hardlimit; /* absolute limit on realtime space */ 343 u64 d_rt_spc_softlimit; /* preferred limit on RT space */
|
/linux-4.1.27/fs/gfs2/ |
H A D | lops.h | 35 unsigned int limit; buf_limit() local 37 limit = (sdp->sd_sb.sb_bsize - BUF_OFFSET) / sizeof(__be64); buf_limit() 38 return limit; buf_limit() 43 unsigned int limit; databuf_limit() local 45 limit = (sdp->sd_sb.sb_bsize - DATABUF_OFFSET) / (2 * sizeof(__be64)); databuf_limit() 46 return limit; databuf_limit()
|
/linux-4.1.27/arch/alpha/include/uapi/asm/ |
H A D | resource.h | 5 * Alpha/Linux-specific ordering of these four resource limit IDs, 9 #define RLIMIT_AS 7 /* address space limit */
|
/linux-4.1.27/fs/romfs/ |
H A D | storage.c | 135 unsigned long pos, size_t limit) romfs_blk_strnlen() 144 while (limit > 0) { romfs_blk_strnlen() 146 segment = min_t(size_t, limit, ROMBSIZE - offset); romfs_blk_strnlen() 155 limit -= segment; romfs_blk_strnlen() 221 size_t limit; romfs_dev_read() local 223 limit = romfs_maxsize(sb); romfs_dev_read() 224 if (pos >= limit) romfs_dev_read() 226 if (buflen > limit - pos) romfs_dev_read() 227 buflen = limit - pos; romfs_dev_read() 246 size_t limit; romfs_dev_strnlen() local 248 limit = romfs_maxsize(sb); romfs_dev_strnlen() 249 if (pos >= limit) romfs_dev_strnlen() 251 if (maxlen > limit - pos) romfs_dev_strnlen() 252 maxlen = limit - pos; romfs_dev_strnlen() 274 size_t limit; romfs_dev_strcmp() local 276 limit = romfs_maxsize(sb); romfs_dev_strcmp() 277 if (pos >= limit) romfs_dev_strcmp() 281 if (size + 1 > limit - pos) romfs_dev_strcmp() 134 romfs_blk_strnlen(struct super_block *sb, unsigned long pos, size_t limit) romfs_blk_strnlen() argument
|
/linux-4.1.27/drivers/gpu/drm/radeon/ |
H A D | kv_smc.c | 76 u32 smc_address, u32 limit) kv_set_smc_sram_address() 80 if ((smc_address + 3) > limit) kv_set_smc_sram_address() 90 u32 *value, u32 limit) kv_read_smc_sram_dword() 94 ret = kv_set_smc_sram_address(rdev, smc_address, limit); kv_read_smc_sram_dword() 120 const u8 *src, u32 byte_count, u32 limit) kv_copy_bytes_to_smc() 125 if ((smc_start_address + byte_count) > limit) kv_copy_bytes_to_smc() 135 ret = kv_set_smc_sram_address(rdev, addr, limit); kv_copy_bytes_to_smc() 161 ret = kv_set_smc_sram_address(rdev, addr, limit); kv_copy_bytes_to_smc() 174 ret = kv_set_smc_sram_address(rdev, addr, limit); kv_copy_bytes_to_smc() 189 ret = kv_set_smc_sram_address(rdev, addr, limit); kv_copy_bytes_to_smc() 207 ret = kv_set_smc_sram_address(rdev, addr, limit); kv_copy_bytes_to_smc() 75 kv_set_smc_sram_address(struct radeon_device *rdev, u32 smc_address, u32 limit) kv_set_smc_sram_address() argument 89 kv_read_smc_sram_dword(struct radeon_device *rdev, u32 smc_address, u32 *value, u32 limit) kv_read_smc_sram_dword() argument 118 kv_copy_bytes_to_smc(struct radeon_device *rdev, u32 smc_start_address, const u8 *src, u32 byte_count, u32 limit) kv_copy_bytes_to_smc() argument
|
H A D | ci_smc.c | 34 u32 smc_address, u32 limit) ci_set_smc_sram_address() 38 if ((smc_address + 3) > limit) ci_set_smc_sram_address() 49 const u8 *src, u32 byte_count, u32 limit) ci_copy_bytes_to_smc() 59 if ((smc_start_address + byte_count) > limit) ci_copy_bytes_to_smc() 69 ret = ci_set_smc_sram_address(rdev, addr, limit); ci_copy_bytes_to_smc() 84 ret = ci_set_smc_sram_address(rdev, addr, limit); ci_copy_bytes_to_smc() 101 ret = ci_set_smc_sram_address(rdev, addr, limit); ci_copy_bytes_to_smc() 207 int ci_load_smc_ucode(struct radeon_device *rdev, u32 limit) ci_load_smc_ucode() argument 268 u32 smc_address, u32 *value, u32 limit) ci_read_smc_sram_dword() 274 ret = ci_set_smc_sram_address(rdev, smc_address, limit); ci_read_smc_sram_dword() 283 u32 smc_address, u32 value, u32 limit) ci_write_smc_sram_dword() 289 ret = ci_set_smc_sram_address(rdev, smc_address, limit); ci_write_smc_sram_dword() 33 ci_set_smc_sram_address(struct radeon_device *rdev, u32 smc_address, u32 limit) ci_set_smc_sram_address() argument 47 ci_copy_bytes_to_smc(struct radeon_device *rdev, u32 smc_start_address, const u8 *src, u32 byte_count, u32 limit) ci_copy_bytes_to_smc() argument 267 ci_read_smc_sram_dword(struct radeon_device *rdev, u32 smc_address, u32 *value, u32 limit) ci_read_smc_sram_dword() argument 282 ci_write_smc_sram_dword(struct radeon_device *rdev, u32 smc_address, u32 value, u32 limit) ci_write_smc_sram_dword() argument
|
H A D | si_smc.c | 34 u32 smc_address, u32 limit) si_set_smc_sram_address() 38 if ((smc_address + 3) > limit) si_set_smc_sram_address() 49 const u8 *src, u32 byte_count, u32 limit) si_copy_bytes_to_smc() 57 if ((smc_start_address + byte_count) > limit) si_copy_bytes_to_smc() 67 ret = si_set_smc_sram_address(rdev, addr, limit); si_copy_bytes_to_smc() 82 ret = si_set_smc_sram_address(rdev, addr, limit); si_copy_bytes_to_smc() 100 ret = si_set_smc_sram_address(rdev, addr, limit); si_copy_bytes_to_smc() 211 int si_load_smc_ucode(struct radeon_device *rdev, u32 limit) si_load_smc_ucode() argument 283 u32 *value, u32 limit) si_read_smc_sram_dword() 289 ret = si_set_smc_sram_address(rdev, smc_address, limit); si_read_smc_sram_dword() 298 u32 value, u32 limit) si_write_smc_sram_dword() 304 ret = si_set_smc_sram_address(rdev, smc_address, limit); si_write_smc_sram_dword() 33 si_set_smc_sram_address(struct radeon_device *rdev, u32 smc_address, u32 limit) si_set_smc_sram_address() argument 47 si_copy_bytes_to_smc(struct radeon_device *rdev, u32 smc_start_address, const u8 *src, u32 byte_count, u32 limit) si_copy_bytes_to_smc() argument 282 si_read_smc_sram_dword(struct radeon_device *rdev, u32 smc_address, u32 *value, u32 limit) si_read_smc_sram_dword() argument 297 si_write_smc_sram_dword(struct radeon_device *rdev, u32 smc_address, u32 value, u32 limit) si_write_smc_sram_dword() argument
|
H A D | rv770_smc.c | 278 u16 smc_address, u16 limit) rv770_set_smc_sram_address() 284 if ((smc_address + 3) > limit) rv770_set_smc_sram_address() 297 u16 byte_count, u16 limit) rv770_copy_bytes_to_smc() 306 if ((smc_start_address + byte_count) > limit) rv770_copy_bytes_to_smc() 316 ret = rv770_set_smc_sram_address(rdev, addr, limit); rv770_copy_bytes_to_smc() 331 ret = rv770_set_smc_sram_address(rdev, addr, limit); rv770_copy_bytes_to_smc() 349 ret = rv770_set_smc_sram_address(rdev, addr, limit); rv770_copy_bytes_to_smc() 467 static void rv770_clear_smc_sram(struct radeon_device *rdev, u16 limit) rv770_clear_smc_sram() argument 473 for (i = 0; i < limit; i += 4) { rv770_clear_smc_sram() 474 rv770_set_smc_sram_address(rdev, i, limit); rv770_clear_smc_sram() 481 u16 limit) rv770_load_smc_ucode() 494 rv770_clear_smc_sram(rdev, limit); rv770_load_smc_ucode() 590 ucode_data, ucode_size, limit); rv770_load_smc_ucode() 604 u16 smc_address, u32 *value, u16 limit) rv770_read_smc_sram_dword() 610 ret = rv770_set_smc_sram_address(rdev, smc_address, limit); rv770_read_smc_sram_dword() 619 u16 smc_address, u32 value, u16 limit) rv770_write_smc_sram_dword() 625 ret = rv770_set_smc_sram_address(rdev, smc_address, limit); rv770_write_smc_sram_dword() 277 rv770_set_smc_sram_address(struct radeon_device *rdev, u16 smc_address, u16 limit) rv770_set_smc_sram_address() argument 295 rv770_copy_bytes_to_smc(struct radeon_device *rdev, u16 smc_start_address, const u8 *src, u16 byte_count, u16 limit) rv770_copy_bytes_to_smc() argument 480 rv770_load_smc_ucode(struct radeon_device *rdev, u16 limit) rv770_load_smc_ucode() argument 603 rv770_read_smc_sram_dword(struct radeon_device *rdev, u16 smc_address, u32 *value, u16 limit) rv770_read_smc_sram_dword() argument 618 rv770_write_smc_sram_dword(struct radeon_device *rdev, u16 smc_address, u32 value, u16 limit) rv770_write_smc_sram_dword() argument
|
H A D | rv770_smc.h | 192 u16 byte_count, u16 limit); 201 u16 smc_address, u32 *value, u16 limit); 203 u16 smc_address, u32 value, u16 limit); 205 u16 limit);
|
/linux-4.1.27/drivers/gpu/drm/gma500/ |
H A D | oaktrail_crtc.c | 46 static bool mrst_lvds_find_best_pll(const struct gma_limit_t *limit, 50 static bool mrst_sdvo_find_best_pll(const struct gma_limit_t *limit, 93 const struct gma_limit_t *limit = NULL; mrst_limit() local 101 limit = &mrst_limits[MRST_LIMIT_LVDS_100L]; mrst_limit() 104 limit = &mrst_limits[MRST_LIMIT_LVDS_83]; mrst_limit() 107 limit = &mrst_limits[MRST_LIMIT_LVDS_100]; mrst_limit() 111 limit = &mrst_limits[MRST_LIMIT_SDVO]; mrst_limit() 113 limit = NULL; mrst_limit() 117 return limit; mrst_limit() 133 static bool mrst_sdvo_find_best_pll(const struct gma_limit_t *limit, mrst_sdvo_find_best_pll() argument 143 for (clock.m = limit->m.min; clock.m <= limit->m.max; clock.m++) { mrst_sdvo_find_best_pll() 144 for (clock.n = limit->n.min; clock.n <= limit->n.max; mrst_sdvo_find_best_pll() 146 for (clock.p1 = limit->p1.min; mrst_sdvo_find_best_pll() 147 clock.p1 <= limit->p1.max; clock.p1++) { mrst_sdvo_find_best_pll() 149 clock.p = clock.p1 * limit->p2.p2_slow; mrst_sdvo_find_best_pll() 153 if (target_vco > limit->vco.max) mrst_sdvo_find_best_pll() 156 if (target_vco < limit->vco.min) mrst_sdvo_find_best_pll() 190 static bool mrst_lvds_find_best_pll(const struct gma_limit_t *limit, mrst_lvds_find_best_pll() argument 199 for (clock.m = limit->m.min; clock.m <= limit->m.max; clock.m++) { mrst_lvds_find_best_pll() 200 for (clock.p1 = limit->p1.min; clock.p1 <= limit->p1.max; mrst_lvds_find_best_pll() 377 const struct gma_limit_t *limit; oaktrail_crtc_mode_set() local 510 limit = mrst_limit(crtc, refclk); oaktrail_crtc_mode_set() 511 ok = limit->find_pll(limit, crtc, adjusted_mode->clock, oaktrail_crtc_mode_set() 670 .limit = mrst_limit,
|
H A D | gma_display.c | 700 const struct gma_limit_t *limit, gma_pll_is_valid() 703 if (clock->p1 < limit->p1.min || limit->p1.max < clock->p1) gma_pll_is_valid() 705 if (clock->p < limit->p.min || limit->p.max < clock->p) gma_pll_is_valid() 707 if (clock->m2 < limit->m2.min || limit->m2.max < clock->m2) gma_pll_is_valid() 709 if (clock->m1 < limit->m1.min || limit->m1.max < clock->m1) gma_pll_is_valid() 714 if (clock->m < limit->m.min || limit->m.max < clock->m) gma_pll_is_valid() 716 if (clock->n < limit->n.min || limit->n.max < clock->n) gma_pll_is_valid() 718 if (clock->vco < limit->vco.min || limit->vco.max < clock->vco) gma_pll_is_valid() 724 if (clock->dot < limit->dot.min || limit->dot.max < clock->dot) gma_pll_is_valid() 730 bool gma_find_best_pll(const struct gma_limit_t *limit, gma_find_best_pll() argument 750 clock.p2 = limit->p2.p2_fast; gma_find_best_pll() 752 clock.p2 = limit->p2.p2_slow; gma_find_best_pll() 754 if (target < limit->p2.dot_limit) gma_find_best_pll() 755 clock.p2 = limit->p2.p2_slow; gma_find_best_pll() 757 clock.p2 = limit->p2.p2_fast; gma_find_best_pll() 763 for (clock.m1 = limit->m1.min; clock.m1 <= limit->m1.max; clock.m1++) { gma_find_best_pll() 764 for (clock.m2 = limit->m2.min; gma_find_best_pll() 766 clock.m2 <= limit->m2.max; clock.m2++) { gma_find_best_pll() 767 for (clock.n = limit->n.min; gma_find_best_pll() 768 clock.n <= limit->n.max; clock.n++) { gma_find_best_pll() 769 for (clock.p1 = limit->p1.min; gma_find_best_pll() 770 clock.p1 <= limit->p1.max; gma_find_best_pll() 777 limit, &clock)) gma_find_best_pll() 699 gma_pll_is_valid(struct drm_crtc *crtc, const struct gma_limit_t *limit, struct gma_clock_t *clock) gma_pll_is_valid() argument
|
H A D | gma_display.h | 58 const struct gma_limit_t *(*limit)(struct drm_crtc *crtc, int refclk); member in struct:gma_clock_funcs 60 const struct gma_limit_t *limit, 101 const struct gma_limit_t *limit, 103 extern bool gma_find_best_pll(const struct gma_limit_t *limit,
|
H A D | psb_intel_display.c | 68 const struct gma_limit_t *limit; psb_intel_limit() local 71 limit = &psb_intel_limits[INTEL_LIMIT_I9XX_LVDS]; psb_intel_limit() 73 limit = &psb_intel_limits[INTEL_LIMIT_I9XX_SDVO_DAC]; psb_intel_limit() 74 return limit; psb_intel_limit() 121 const struct gma_limit_t *limit; psb_intel_crtc_mode_set() local 151 limit = gma_crtc->clock_funcs->limit(crtc, refclk); psb_intel_crtc_mode_set() 153 ok = limit->find_pll(limit, crtc, adjusted_mode->clock, refclk, psb_intel_crtc_mode_set() 453 .limit = psb_intel_limit,
|
/linux-4.1.27/arch/sparc/include/asm/ |
H A D | cpu_type.h | 20 #define SUN4M_NCPUS 4 /* Architectural limit of sun4m. */
|
H A D | obio.h | 122 unsigned limit; bw_get_prof_limit() local 125 "=r" (limit) : bw_get_prof_limit() 128 return limit; bw_get_prof_limit() 131 static inline void bw_set_prof_limit(int cpu, unsigned limit) bw_set_prof_limit() argument 134 "r" (limit), bw_set_prof_limit()
|
H A D | timer_32.h | 25 * When a counter reaches the value in the corresponding limit register,
|
/linux-4.1.27/drivers/gpu/drm/nouveau/include/nvkm/engine/ |
H A D | dmaobj.h | 11 u64 limit; member in struct:nvkm_dmaobj
|
H A D | falcon.h | 42 u32 limit; member in struct:nvkm_falcon::__anon4111 48 u32 limit; member in struct:nvkm_falcon::__anon4112
|
/linux-4.1.27/include/uapi/linux/netfilter/ |
H A D | xt_connlimit.h | 24 unsigned int limit; member in struct:xt_connlimit_info
|
H A D | xt_limit.h | 15 __u32 burst; /* Period multiplier for upper limit. */
|
H A D | xt_u32.h | 25 * For now, I settle with a limit of 10 each.
|
H A D | xt_hashlimit.h | 30 __u32 burst; /* Period multiplier for upper limit. */ 54 __u32 burst; /* Period multiplier for upper limit. */
|
/linux-4.1.27/fs/dlm/ |
H A D | midcomms.h | 18 unsigned len, unsigned limit);
|
H A D | midcomms.c | 35 unsigned len, unsigned limit) copy_from_cb() 39 if ((copy + offset) > limit) copy_from_cb() 40 copy = limit - offset; copy_from_cb() 59 unsigned offset, unsigned len, unsigned limit) dlm_process_incoming_buffer() 79 limit); dlm_process_incoming_buffer() 120 copy_from_cb(p, base, offset, msglen, limit); dlm_process_incoming_buffer() 126 offset &= (limit - 1); dlm_process_incoming_buffer() 34 copy_from_cb(void *dst, const void *base, unsigned offset, unsigned len, unsigned limit) copy_from_cb() argument 58 dlm_process_incoming_buffer(int nodeid, const void *base, unsigned offset, unsigned len, unsigned limit) dlm_process_incoming_buffer() argument
|
/linux-4.1.27/tools/perf/tests/ |
H A D | dso-data.c | 231 pr_debug("file limit %ld, new %d\n", (long) rlim.rlim_cur, n); set_fd_limit() 241 int dso_cnt, limit, i, fd; test__dso_data_cache() local 245 /* set as system limit */ test__dso_data_cache() 246 limit = nr * 4; test__dso_data_cache() 247 TEST_ASSERT_VAL("failed to set file limit", !set_fd_limit(limit)); test__dso_data_cache() 249 /* and this is now our dso open FDs limit */ test__dso_data_cache() 250 dso_cnt = limit / 2; test__dso_data_cache() 259 * file and keep it open (unless open file limit). test__dso_data_cache() 277 /* open +1 dso to reach the allowed limit */ test__dso_data_cache() 309 * - set process file descriptor limit to current test__dso_data_reopen() 312 * reach the files count limit test__dso_data_reopen() 316 TEST_ASSERT_VAL("failed to set file limit", test__dso_data_reopen() 331 * reached the files count limit test__dso_data_reopen() 342 * the file descriptor limit test__dso_data_reopen() 352 * the file descriptor limit test__dso_data_reopen()
|
/linux-4.1.27/drivers/video/backlight/ |
H A D | pcf50633-backlight.c | 38 * Update the brightness limit for the pc50633 backlight. The actual brightness 39 * will not go above the limit. This is useful to limit power drain for example 43 * @limit: The brightness limit. Valid values are 0-63 45 int pcf50633_bl_set_brightness_limit(struct pcf50633 *pcf, unsigned int limit) pcf50633_bl_set_brightness_limit() argument 52 pcf_bl->brightness_limit = limit & 0x3f; pcf50633_bl_set_brightness_limit()
|
/linux-4.1.27/drivers/net/wireless/ath/ath9k/ |
H A D | calib.c | 50 struct ath_nf_limits *limit; ath9k_hw_get_nf_limits() local 53 limit = &ah->nf_2g; ath9k_hw_get_nf_limits() 55 limit = &ah->nf_5g; ath9k_hw_get_nf_limits() 57 return limit; ath9k_hw_get_nf_limits() 86 struct ath_nf_limits *limit; ath9k_hw_update_nfcal_hist_buffer() local 93 limit = ath9k_hw_get_nf_limits(ah, ah->curchan); ath9k_hw_update_nfcal_hist_buffer() 116 if (h[i].privNF > limit->max) { ath9k_hw_update_nfcal_hist_buffer() 121 i, h[i].privNF, limit->max, ath9k_hw_update_nfcal_hist_buffer() 127 * Normally we limit the average noise floor by the ath9k_hw_update_nfcal_hist_buffer() 130 * we bypass this limit here in order to better deal ath9k_hw_update_nfcal_hist_buffer() 134 h[i].privNF = limit->max; ath9k_hw_update_nfcal_hist_buffer() 330 struct ath_nf_limits *limit; ath9k_hw_nf_sanitize() local 334 limit = &ah->nf_2g; ath9k_hw_nf_sanitize() 336 limit = &ah->nf_5g; ath9k_hw_nf_sanitize() 346 if (nf[i] > limit->max) { ath9k_hw_nf_sanitize() 349 i, nf[i], limit->max); ath9k_hw_nf_sanitize() 350 nf[i] = limit->max; ath9k_hw_nf_sanitize() 351 } else if (nf[i] < limit->min) { ath9k_hw_nf_sanitize() 354 i, nf[i], limit->min); ath9k_hw_nf_sanitize() 355 nf[i] = limit->nominal; ath9k_hw_nf_sanitize()
|
/linux-4.1.27/include/linux/power/ |
H A D | smb347-charger.h | 29 /* Use default factory programmed value for hard/soft temperature limit */ 57 * @soft_cold_temp_limit: soft cold temperature limit [%0 - %15] (in degree C), 59 * @soft_hot_temp_limit: soft hot temperature limit [%40 - %55] (in degree C), 61 * @hard_cold_temp_limit: hard cold temperature limit [%-5 - %10] (in degree C), 63 * @hard_hot_temp_limit: hard hot temperature limit [%50 - %65] (in degree C), 65 * @suspend_on_hard_temp_limit: suspend charging when hard limit is hit 67 * limit is hit 82 * Hard and soft temperature limit values are given as described in the 87 * hot limit to be %53 deg C, @hard_hot_temp_limit should be set to %50.
|
/linux-4.1.27/arch/sparc/mm/ |
H A D | io-unit.c | 52 iounit->limit[0] = IOUNIT_BMAP1_START; iounit_iommu_init() 53 iounit->limit[1] = IOUNIT_BMAP2_START; iounit_iommu_init() 54 iounit->limit[2] = IOUNIT_BMAPM_START; iounit_iommu_init() 55 iounit->limit[3] = IOUNIT_BMAPM_END; iounit_iommu_init() 97 unsigned long rotor, scan, limit; iounit_get_area() local 113 limit = iounit->limit[j]; iounit_get_area() 115 nexti: scan = find_next_zero_bit(iounit->bmap, limit, scan); iounit_get_area() 116 if (scan + npages > limit) { iounit_get_area() 117 if (limit != rotor) { iounit_get_area() 118 limit = rotor; iounit_get_area() 119 scan = iounit->limit[j - 1]; iounit_get_area() 130 iounit->rotor[j - 1] = (scan < limit) ? scan : iounit->limit[j - 1]; iounit_get_area()
|
/linux-4.1.27/drivers/gpu/drm/nouveau/ |
H A D | nv50_fence.c | 42 u32 limit = start + mem->size - 1; nv50_fence_context_new() local 59 .limit = limit, nv50_fence_context_new() 67 u32 limit = start + bo->bo.mem.size - 1; nv50_fence_context_new() local 74 .limit = limit, nv50_fence_context_new()
|
H A D | nouveau_chan.c | 139 args.limit = cli->vm->mmu->limit - 1; nouveau_channel_prep() 150 args.limit = args.start + device->info.ram_user - 1; nouveau_channel_prep() 155 args.limit = device->info.ram_user - 1; nouveau_channel_prep() 162 args.limit = chan->drm->agp.base + nouveau_channel_prep() 168 args.limit = mmu->limit - 1; nouveau_channel_prep() 298 args.limit = cli->vm->mmu->limit - 1; nouveau_channel_init() 303 args.limit = device->info.ram_user - 1; nouveau_channel_init() 316 args.limit = cli->vm->mmu->limit - 1; nouveau_channel_init() 322 args.limit = chan->drm->agp.base + nouveau_channel_init() 328 args.limit = mmu->limit - 1; nouveau_channel_init()
|
H A D | nv17_fence.c | 80 u32 limit = start + mem->size - 1; nv17_fence_context_new() local 97 .limit = limit, nv17_fence_context_new()
|
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/subdev/bios/ |
H A D | shadowacpi.c | 51 u32 limit = (offset + length + 0xfff) & ~0xfff; acpi_read_fast() local 53 u32 fetch = limit - start; acpi_read_fast() 55 if (nvbios_extend(bios, limit) >= 0) { acpi_read_fast() 72 u32 limit = (offset + length + 0xfff) & ~0xfff; acpi_read_slow() local 76 if (nvbios_extend(bios, limit) >= 0) { acpi_read_slow() 77 while (start + fetch < limit) { acpi_read_slow()
|
/linux-4.1.27/arch/x86/include/uapi/asm/ |
H A D | ldt.h | 16 * Note on 64bit base and limit is ignored and you cannot set DS/ES/CS 23 unsigned int limit; member in struct:user_desc
|
/linux-4.1.27/block/partitions/ |
H A D | check.h | 20 int limit; member in struct:parsed_partitions 43 if (n < p->limit) { put_partition()
|
H A D | karma.c | 45 if (slot == state->limit) karma_partition()
|
H A D | atari.c | 66 for (slot = 1; pi < &rs->part[4] && slot < state->limit; slot++, pi++) { atari_partition() 118 if (++slot == state->limit) { atari_partition() 131 for (; pi < &rs->icdpart[8] && slot < state->limit; slot++, pi++) { atari_partition()
|
H A D | mac.c | 67 if (blocks_in_map >= state->limit) mac_partition() 68 blocks_in_map = state->limit - 1; mac_partition()
|
/linux-4.1.27/arch/mips/include/uapi/asm/ |
H A D | resource.h | 14 * These five resource limit IDs have a MIPS/Linux-specific ordering, 18 #define RLIMIT_AS 6 /* address space limit */
|
/linux-4.1.27/security/apparmor/ |
H A D | resource.c | 42 * audit_resource - audit setting resource limit 85 * @new_rlim - the new resource limit (NOT NULL) 87 * Control raising the processes hard limit. 127 /* for any rlimits the profile controlled reset the soft limit __aa_transition_rlimits() 128 * to the less of the tasks hard limit and the init tasks soft limit __aa_transition_rlimits() 151 /* soft limit should not exceed hard limit */ __aa_transition_rlimits()
|
/linux-4.1.27/arch/sparc/include/uapi/asm/ |
H A D | resource.h | 11 * These two resource limit IDs have a Sparc/Linux-specific ordering,
|
/linux-4.1.27/arch/x86/include/asm/ |
H A D | desc_defs.h | 32 unsigned limit: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8; member in struct:desc_struct::__anon3027::__anon3029 37 #define GDT_ENTRY_INIT(flags, base, limit) { { { \ 38 .a = ((limit) & 0xffff) | (((base) & 0xffff) << 16), \ 40 ((limit) & 0xf0000) | ((base) & 0xff000000), \
|
H A D | desc.h | 13 desc->limit0 = info->limit & 0x0ffff; fill_ldt() 24 desc->limit = (info->limit & 0xf0000) >> 16; fill_ldt() 144 unsigned long limit, unsigned char type, pack_descriptor() 147 desc->a = ((base & 0xffff) << 16) | (limit & 0xffff); pack_descriptor() 149 (limit & 0x000f0000) | ((type & 0xff) << 8) | pack_descriptor() 184 * -1? seg base+limit should be pointing to the address of the __set_tss_desc() 257 (info)->limit == 0 && \ 269 info->limit == 0 && LDT_zero() 297 return desc->limit0 | (desc->limit << 16); get_desc_limit() 300 static inline void set_desc_limit(struct desc_struct *desc, unsigned long limit) set_desc_limit() argument 302 desc->limit0 = limit & 0xffff; set_desc_limit() 303 desc->limit = (limit >> 16) & 0xf; set_desc_limit() 143 pack_descriptor(struct desc_struct *desc, unsigned long base, unsigned long limit, unsigned char type, unsigned char flags) pack_descriptor() argument
|
H A D | page_32_types.h | 30 /* 44=32+12, the limit we can fit into an unsigned long pfn */
|
/linux-4.1.27/arch/microblaze/include/asm/ |
H A D | dma.h | 13 /* we don't have dma address limit. define it as zero to be
|
/linux-4.1.27/arch/mips/include/asm/ |
H A D | mips_mt.h | 11 * How many VPEs and TCs is Linux allowed to use? 0 means no limit.
|
/linux-4.1.27/arch/powerpc/mm/ |
H A D | subpage-prot.c | 100 unsigned long next, limit; subpage_prot_clear() local 103 limit = addr + len; subpage_prot_clear() 104 if (limit > spt->maxaddr) subpage_prot_clear() 105 limit = spt->maxaddr; subpage_prot_clear() 106 for (; addr < limit; addr = next) { subpage_prot_clear() 107 next = pmd_addr_end(addr, limit); subpage_prot_clear() 195 unsigned long next, limit; sys_subpage_prot() local 217 for (limit = addr + len; addr < limit; addr = next) { sys_subpage_prot() 218 next = pmd_addr_end(addr, limit); sys_subpage_prot() 260 if (limit > spt->maxaddr) sys_subpage_prot() 261 spt->maxaddr = limit; sys_subpage_prot()
|
H A D | fsl_booke_mmu.c | 66 unsigned long limit; member in struct:tlbcamrange 72 return tlbcam_addrs[idx].limit - tlbcam_addrs[idx].start + 1; tlbcam_sz() 82 if (va >= tlbcam_addrs[b].start && va < tlbcam_addrs[b].limit) v_mapped_by_tlbcam() 95 && pa < (tlbcam_addrs[b].limit-tlbcam_addrs[b].start) p_mapped_by_tlbcam() 142 tlbcam_addrs[index].limit = virt + size - 1; settlbcam() 218 return tlbcam_addrs[tlbcam_index - 1].limit - PAGE_OFFSET + 1; mmu_mapin_ram() 253 phys_addr_t limit = first_memblock_base + first_memblock_size; setup_initial_memory_limit() local 256 memblock_set_current_limit(min_t(u64, limit, 0x04000000)); setup_initial_memory_limit()
|
H A D | ppc_mmu_32.c | 45 unsigned long limit; member in struct:batrange 56 if (va >= bat_addrs[b].start && va < bat_addrs[b].limit) v_mapped_by_bats() 69 && pa < (bat_addrs[b].limit-bat_addrs[b].start) p_mapped_by_bats() 96 done = (unsigned long)bat_addrs[2].limit - PAGE_OFFSET + 1; mmu_mapin_ram() 97 if ((done < tot) && !bat_addrs[3].limit) { mmu_mapin_ram() 104 done = (unsigned long)bat_addrs[3].limit - PAGE_OFFSET + 1; mmu_mapin_ram() 158 bat_addrs[index].limit = virt + ((bl + 1) << 17) - 1; setbat()
|
/linux-4.1.27/arch/arm/mach-rpc/include/mach/ |
H A D | acornfb.h | 18 u_long limit; acornfb_valid_pixrate() local 28 limit = 6578; acornfb_valid_pixrate() 30 limit = 13157; acornfb_valid_pixrate() 32 limit = 26315; acornfb_valid_pixrate() 35 return acornfb_bandwidth(var) >= limit; acornfb_valid_pixrate()
|
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/engine/ |
H A D | falcon.c | 96 falcon->code.limit = (caps & 0x000001ff) << 8; _nvkm_falcon_init() 97 falcon->data.limit = (caps & 0x0003fe00) >> 1; _nvkm_falcon_init() 101 nv_debug(falcon, "code limit: %d\n", falcon->code.limit); _nvkm_falcon_init() 102 nv_debug(falcon, "data limit: %d\n", falcon->data.limit); _nvkm_falcon_init() 197 if (falcon->code.size > falcon->code.limit || _nvkm_falcon_init() 198 falcon->data.size > falcon->data.limit) { _nvkm_falcon_init() 199 nv_error(falcon, "ucode exceeds falcon limit(s)\n"); _nvkm_falcon_init() 222 for (; i < falcon->data.limit; i += 4) _nvkm_falcon_init() 228 for (; i < falcon->data.limit / 4; i++) _nvkm_falcon_init()
|
/linux-4.1.27/arch/powerpc/kernel/ |
H A D | paca.c | 49 static void __init allocate_lppacas(int nr_cpus, unsigned long limit) allocate_lppacas() argument 57 PAGE_SIZE, limit)); allocate_lppacas() 91 static inline void allocate_lppacas(int nr_cpus, unsigned long limit) { } free_lppacas() argument 107 static void __init allocate_slb_shadows(int nr_cpus, int limit) allocate_slb_shadows() argument 110 slb_shadow = __va(memblock_alloc_base(size, PAGE_SIZE, limit)); allocate_slb_shadows() 134 static void __init allocate_slb_shadows(int nr_cpus, int limit) { } allocate_slb_shadows() argument 207 int cpu, limit; allocate_pacas() local 214 limit = min(0x10000000ULL, ppc64_rma_size); allocate_pacas() 218 paca = __va(memblock_alloc_base(paca_size, PAGE_SIZE, limit)); allocate_pacas() 224 allocate_lppacas(nr_cpu_ids, limit); allocate_pacas() 226 allocate_slb_shadows(nr_cpu_ids, limit); allocate_pacas()
|
/linux-4.1.27/fs/configfs/ |
H A D | item.c | 69 int limit = CONFIGFS_ITEM_NAME_LEN; config_item_set_name() local 78 need = vsnprintf(item->ci_namebuf, limit, fmt, args); config_item_set_name() 80 if (need < limit) config_item_set_name() 86 limit = need + 1; config_item_set_name() 87 name = kmalloc(limit, GFP_KERNEL); config_item_set_name() 93 need = vsnprintf(name, limit, fmt, args); config_item_set_name() 97 if (need >= limit) { config_item_set_name()
|
/linux-4.1.27/sound/pci/aw2/ |
H A D | aw2-saa7146.c | 167 /* No MMU -> nothing to do with PageA1, we only configure the limit of snd_aw2_saa7146_pcm_init_playback() 173 The limit register defines an address limit, which generates snd_aw2_saa7146_pcm_init_playback() 177 defines a limit of 128 bytes, '0011' one of 256 bytes, and snd_aw2_saa7146_pcm_init_playback() 193 /* Define upper limit for DMA access */ snd_aw2_saa7146_pcm_init_playback() 204 /* Define upper limit for DMA access */ snd_aw2_saa7146_pcm_init_playback() 224 /* No MMU -> nothing to do with PageA1, we only configure the limit of snd_aw2_saa7146_pcm_init_capture() 230 The limit register defines an address limit, which generates snd_aw2_saa7146_pcm_init_capture() 234 defines a limit of 128 bytes, '0011' one of 256 bytes, and snd_aw2_saa7146_pcm_init_capture() 250 /* Define upper limit for DMA access */ snd_aw2_saa7146_pcm_init_capture() 455 int limit = 0; snd_aw2_saa7146_get_limit() local 458 limit++; snd_aw2_saa7146_get_limit() 460 return limit; snd_aw2_saa7146_get_limit()
|
/linux-4.1.27/drivers/clk/bcm/ |
H A D | clk-kona-setup.c | 31 u32 limit; ccu_data_offsets_valid() local 33 limit = ccu->range - sizeof(u32); ccu_data_offsets_valid() 34 limit = round_down(limit, sizeof(u32)); ccu_data_offsets_valid() 36 if (ccu_policy->enable.offset > limit) { ccu_data_offsets_valid() 39 ccu->name, ccu_policy->enable.offset, limit); ccu_data_offsets_valid() 42 if (ccu_policy->control.offset > limit) { ccu_data_offsets_valid() 45 ccu->name, ccu_policy->control.offset, limit); ccu_data_offsets_valid() 90 u32 limit; peri_clk_data_offsets_valid() local 97 limit = range - sizeof(u32); peri_clk_data_offsets_valid() 98 limit = round_down(limit, sizeof(u32)); peri_clk_data_offsets_valid() 102 if (policy->offset > limit) { peri_clk_data_offsets_valid() 104 __func__, name, policy->offset, limit); peri_clk_data_offsets_valid() 112 if (gate->offset > limit) { peri_clk_data_offsets_valid() 114 __func__, name, gate->offset, limit); peri_clk_data_offsets_valid() 119 if (hyst->offset > limit) { peri_clk_data_offsets_valid() 122 name, hyst->offset, limit); peri_clk_data_offsets_valid() 133 if (div->u.s.offset > limit) { peri_clk_data_offsets_valid() 135 __func__, name, div->u.s.offset, limit); peri_clk_data_offsets_valid() 142 if (div->u.s.offset > limit) { peri_clk_data_offsets_valid() 145 __func__, name, div->u.s.offset, limit); peri_clk_data_offsets_valid() 152 if (sel->offset > limit) { peri_clk_data_offsets_valid() 154 __func__, name, sel->offset, limit); peri_clk_data_offsets_valid() 161 if (trig->offset > limit) { peri_clk_data_offsets_valid() 163 __func__, name, trig->offset, limit); peri_clk_data_offsets_valid() 170 if (trig->offset > limit) { peri_clk_data_offsets_valid() 172 __func__, name, trig->offset, limit); peri_clk_data_offsets_valid() 184 u32 limit = BITS_PER_BYTE * sizeof(u32) - 1; bit_posn_valid() local 186 if (bit_posn > limit) { bit_posn_valid() 188 field_name, clock_name, bit_posn, limit); bit_posn_valid() 204 u32 limit = BITS_PER_BYTE * sizeof(u32); bitfield_valid() local 211 if (shift + width > limit) { bitfield_valid() 213 field_name, clock_name, shift, width, limit); bitfield_valid() 301 u32 limit; sel_valid() local 312 limit = (1 << sel->width) - 1; sel_valid() 313 if (max_sel > limit) { sel_valid() 375 u32 limit; kona_dividers_valid() local 387 limit = BITS_PER_BYTE * sizeof(u32); kona_dividers_valid() 389 return div->u.s.frac_width + pre_div->u.s.frac_width <= limit; kona_dividers_valid() 568 /* Avoid exceeding our parent clock limit */ parent_process()
|
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/subdev/bar/ |
H A D | nv50.c | 114 u64 start, limit; nv50_bar_ctor() local 140 limit = start + nv_device_resource_len(device, 3); nv50_bar_ctor() 142 ret = nvkm_vm_new(device, start, limit, start, &vm); nv50_bar_ctor() 149 ((limit-- - start) >> 12) * 8, 0x1000, nv50_bar_ctor() 165 nv_wo32(priv->bar3, 0x04, lower_32_bits(limit)); nv50_bar_ctor() 167 nv_wo32(priv->bar3, 0x0c, upper_32_bits(limit) << 24 | nv50_bar_ctor() 174 limit = start + nv_device_resource_len(device, 1); nv50_bar_ctor() 176 ret = nvkm_vm_new(device, start, limit--, start, &vm); nv50_bar_ctor() 192 nv_wo32(priv->bar1, 0x04, lower_32_bits(limit)); nv50_bar_ctor() 194 nv_wo32(priv->bar1, 0x0c, upper_32_bits(limit) << 24 | nv50_bar_ctor()
|
/linux-4.1.27/drivers/base/ |
H A D | dma-contiguous.c | 100 * @limit: End address of the reserved memory (optional, 0 for any). 107 void __init dma_contiguous_reserve(phys_addr_t limit) dma_contiguous_reserve() argument 111 phys_addr_t selected_limit = limit; dma_contiguous_reserve() 114 pr_debug("%s(limit %08lx)\n", __func__, (unsigned long)limit); dma_contiguous_reserve() 119 selected_limit = min_not_zero(limit_cmdline, limit); dma_contiguous_reserve() 149 * @limit: End address of the reserved memory (optional, 0 for any). 160 * reserve in range from @base to @limit. 163 phys_addr_t limit, struct cma **res_cma, dma_contiguous_reserve_area() 168 ret = cma_declare_contiguous(base, size, limit, 0, 0, fixed, res_cma); dma_contiguous_reserve_area() 162 dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base, phys_addr_t limit, struct cma **res_cma, bool fixed) dma_contiguous_reserve_area() argument
|
/linux-4.1.27/drivers/tty/serial/ |
H A D | sunhv.c | 78 int limit = 10000; receive_chars_getchar() local 80 while (limit-- > 0) { receive_chars_getchar() 121 int limit = 10000; receive_chars_read() local 123 while (limit-- > 0) { receive_chars_read() 269 int limit = 10000; sunhv_send_xchar() local 276 while (limit-- > 0) { sunhv_send_xchar() 296 int limit = 10000; sunhv_break_ctl() local 300 while (limit-- > 0) { sunhv_break_ctl() 448 int limit = 1000000; sunhv_console_write_paged() local 450 while (limit--) { sunhv_console_write_paged() 459 if (limit < 0) sunhv_console_write_paged() 472 int limit = 1000000; sunhv_console_putchar() local 474 while (limit-- > 0) { sunhv_console_putchar()
|
/linux-4.1.27/drivers/scsi/be2iscsi/ |
H A D | be.h | 48 static inline u32 MODULO(u16 val, u16 limit) MODULO() argument 50 WARN_ON(limit & (limit - 1)); MODULO() 51 return val & (limit - 1); MODULO() 54 static inline void index_inc(u16 *index, u16 limit) index_inc() argument 56 *index = MODULO((*index + 1), limit); index_inc()
|
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/engine/dmaobj/ |
H A D | base.c | 82 "start %016llx limit %016llx\n", nvkm_dmaobj_create_() 84 args->v0.start, args->v0.limit); nvkm_dmaobj_create_() 88 dmaobj->limit = args->v0.limit; nvkm_dmaobj_create_() 95 if (dmaobj->start > dmaobj->limit) nvkm_dmaobj_create_() 104 if (dmaobj->limit >= pfb->ram->size - instmem->reserved) nvkm_dmaobj_create_()
|
/linux-4.1.27/arch/mips/ath25/ |
H A D | board.c | 57 static const void __iomem * __init find_board_config(const void __iomem *limit, find_board_config() argument 61 const void __iomem *begin = limit - 0x1000; find_board_config() 62 const void __iomem *end = limit - 0x30000; find_board_config() 71 static const void __iomem * __init find_radio_config(const void __iomem *limit, find_radio_config() argument 82 end = limit; find_radio_config() 89 end = limit - 0x1000 + 0xf8; find_radio_config()
|
/linux-4.1.27/fs/jfs/ |
H A D | jfs_types.h | 142 * DASD limit information - stored in directory inode 148 u8 limit_hi; /* DASD limit (in logical blocks) */ 149 __le32 limit_lo; /* DASD limit (in logical blocks) */ 157 #define setDASDLIMIT(dasdp, limit)\ 159 (dasdp)->limit_hi = ((u64)limit) >> 32;\ 160 (dasdp)->limit_lo = __cpu_to_le32(limit);\
|
/linux-4.1.27/drivers/staging/rtl8712/ |
H A D | ieee80211.c | 111 index: the information element id index, limit is the limit for search 113 u8 *r8712_get_ie(u8 *pbuf, sint index, sint *len, sint limit) r8712_get_ie() argument 118 if (limit < 1) r8712_get_ie() 131 if (i >= limit) r8712_get_ie() 218 unsigned char *r8712_get_wpa_ie(unsigned char *pie, int *wpa_ie_len, int limit) r8712_get_wpa_ie() argument 226 pbuf = r8712_get_ie(pbuf, _WPA_IE_ID_, &len, limit); r8712_get_wpa_ie() 243 limit = limit - (pbuf - pie) - 2 - len; r8712_get_wpa_ie() 244 if (limit <= 0) r8712_get_wpa_ie() 252 unsigned char *r8712_get_wpa2_ie(unsigned char *pie, int *rsn_ie_len, int limit) r8712_get_wpa2_ie() argument 254 return r8712_get_ie(pie, _WPA2_IE_ID_, rsn_ie_len, limit); r8712_get_wpa2_ie()
|
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ |
H A D | nv10.c | 33 tile->limit = max(1u, addr + size) - 1; nv10_fb_tile_init() 41 tile->limit = 0; nv10_fb_tile_fini() 49 nv_wr32(pfb, 0x100244 + (i * 0x10), tile->limit); nv10_fb_tile_prog()
|
H A D | nv20.c | 33 tile->limit = max(1u, addr + size) - 1; nv20_fb_tile_init() 62 tile->limit = 0; nv20_fb_tile_fini() 71 nv_wr32(pfb, 0x100244 + (i * 0x10), tile->limit); nv20_fb_tile_prog()
|
H A D | nv44.c | 34 tile->limit = max(1u, addr + size) - 1; nv44_fb_tile_init() 41 nv_wr32(pfb, 0x100604 + (i * 0x10), tile->limit); nv44_fb_tile_prog()
|
/linux-4.1.27/fs/minix/ |
H A D | dir.c | 104 char *p, *kaddr, *limit; minix_readdir() local 111 limit = kaddr + minix_last_byte(inode, n) - chunk_size; minix_readdir() 112 for ( ; p <= limit; p = minix_next_entry(p, sbi)) { minix_readdir() 172 char *kaddr, *limit; minix_find_entry() local 179 limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize; minix_find_entry() 180 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { minix_find_entry() 228 char *limit, *dir_end; minix_add_link() local 237 limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize; minix_add_link() 238 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { minix_add_link() 374 char *p, *kaddr, *limit; minix_empty_dir() local 381 limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize; minix_empty_dir() 382 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { minix_empty_dir()
|
/linux-4.1.27/arch/x86/pci/ |
H A D | numachip.c | 19 static u8 limit __read_mostly; 42 if (unlikely(bus == 0 && devfn >= limit)) { pci_mmcfg_read_numachip() 80 if (unlikely(bus == 0 && devfn >= limit)) pci_mmcfg_write_numachip() 123 limit = PCI_DEVFN(0x18 + ((val >> 4) & 7) + 1, 0); pci_numachip_init()
|
/linux-4.1.27/arch/x86/um/shared/sysdep/ |
H A D | tls.h | 13 unsigned int limit; member in struct:um_dup_user_desc
|
/linux-4.1.27/include/net/ |
H A D | ip6_tunnel.h | 22 __u8 encap_limit; /* encapsulation limit for tunnel */ 23 __u8 hop_limit; /* hop limit for tunnel */ 55 /* Tunnel encapsulation limit destination sub-option */ 60 __u8 encap_limit; /* tunnel encapsulation limit */
|
H A D | pkt_sched.h | 83 int fifo_set_limit(struct Qdisc *q, unsigned int limit); 85 unsigned int limit);
|
/linux-4.1.27/include/uapi/linux/usb/ |
H A D | cdc-wdm.h | 16 * defining the message limit for both reading and writing.
|
/linux-4.1.27/net/appletalk/ |
H A D | sysctl_net_atalk.c | 29 .procname = "aarp-retransmit-limit",
|
/linux-4.1.27/drivers/usb/mon/ |
H A D | mon_text.c | 32 * This limit exists to prevent OOMs when the user process stops reading. 40 * Potentially unlimited number; we limit it for similar allocations. 96 int cnt, limit; member in struct:mon_text_ptr 394 ptr.limit = rp->printf_size; mon_text_read_t() 398 ptr.cnt += snprintf(ptr.pbuf + ptr.cnt, ptr.limit - ptr.cnt, mon_text_read_t() 421 ptr.limit = rp->printf_size; mon_text_read_u() 434 ptr.cnt += snprintf(ptr.pbuf + ptr.cnt, ptr.limit - ptr.cnt, mon_text_read_u() 488 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_head_t() 506 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_head_u() 517 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_statset() 525 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_statset() 528 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_statset() 536 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_intstat() 544 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_isostat() 547 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_isostat() 560 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_isodesc() 569 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_isodesc() 582 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_data() 589 p->limit - p->cnt, mon_text_read_data() 593 p->limit - p->cnt, mon_text_read_data() 596 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_data() 599 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, mon_text_read_data() 603 p->cnt += snprintf(p->pbuf + p->cnt, p->limit - p->cnt, "\n"); mon_text_read_data()
|
/linux-4.1.27/drivers/staging/lustre/lustre/ldlm/ |
H A D | ldlm_pool.c | 49 * have all locks of limit ->pl_limit for 10h. 153 * Formula is the following: limit * 10h / 1 client. ldlm_pool_slv_max() 208 * SLV growing means more locks cached on clients until limit or grant ldlm_pool_t2gsp() 217 * Recalculates next grant limit on passed \a pl. 223 int granted, grant_step, limit; ldlm_pool_recalc_grant_plan() local 225 limit = ldlm_pool_get_limit(pl); ldlm_pool_recalc_grant_plan() 229 grant_step = ((limit - granted) * grant_step) / 100; ldlm_pool_recalc_grant_plan() 231 limit = (limit * 5) >> 2; ldlm_pool_recalc_grant_plan() 232 if (pl->pl_grant_plan > limit) ldlm_pool_recalc_grant_plan() 233 pl->pl_grant_plan = limit; ldlm_pool_recalc_grant_plan() 249 __u32 limit; ldlm_pool_recalc_slv() local 253 limit = ldlm_pool_get_limit(pl); ldlm_pool_recalc_slv() 255 round_up = granted < limit; ldlm_pool_recalc_slv() 257 grant_usage = max_t(int, limit - (granted - grant_plan), 1); ldlm_pool_recalc_slv() 261 * from limit. SLV changes as fast as the ratio of grant plan ldlm_pool_recalc_slv() 268 do_div(slv_factor, limit); ldlm_pool_recalc_slv() 272 if (slv > ldlm_pool_slv_max(limit)) ldlm_pool_recalc_slv() 273 slv = ldlm_pool_slv_max(limit); ldlm_pool_recalc_slv() 274 else if (slv < ldlm_pool_slv_min(limit)) ldlm_pool_recalc_slv() 275 slv = ldlm_pool_slv_min(limit); ldlm_pool_recalc_slv() 379 __u32 limit; ldlm_srv_pool_shrink() local 411 limit = ldlm_pool_get_limit(pl); ldlm_srv_pool_shrink() 412 pl->pl_server_lock_volume = ldlm_pool_slv_min(limit); ldlm_srv_pool_shrink() 429 * Setup server side pool \a pl with passed \a limit. 431 static int ldlm_srv_pool_setup(struct ldlm_pool *pl, int limit) ldlm_srv_pool_setup() argument 439 obd->obd_pool_limit = limit; ldlm_srv_pool_setup() 442 ldlm_pool_set_limit(pl, limit); ldlm_srv_pool_setup() 647 * Sets passed \a limit into pool \a pl. 649 int ldlm_pool_setup(struct ldlm_pool *pl, int limit) ldlm_pool_setup() argument 652 return pl->pl_ops->po_setup(pl, limit); ldlm_pool_setup() 664 __u32 limit; lprocfs_pool_state_seq_show() local 669 limit = ldlm_pool_get_limit(pl); lprocfs_pool_state_seq_show() 693 granted, limit); lprocfs_pool_state_seq_show() 775 LDLM_POOL_ADD_VAR("limit", &pl->pl_limit, &ldlm_pool_rw_atomic_fops); ldlm_pool_proc_init() 1016 * Returns current \a pl limit. 1025 * Sets passed \a limit to \a pl. 1027 void ldlm_pool_set_limit(struct ldlm_pool *pl, __u32 limit) ldlm_pool_set_limit() argument 1029 atomic_set(&pl->pl_limit, limit); ldlm_pool_set_limit() 1191 * No need to setup pool limit for client pools. ldlm_pools_recalc() 1208 * Set the modest pools limit equal to their avg granted list_for_each_entry() 1219 * of limit. 1222 CWARN("\"Modest\" pools eat out 2/3 of server locks limit (%d of %lu). This means that you have too many clients for this amount of server RAM. Upgrade server!\n", 1238 * modest pools, we re-setup equal limit list_for_each_entry()
|
/linux-4.1.27/drivers/hwmon/ |
H A D | max197.c | 46 * @limit: Max range value (10V for MAX197, 4V for MAX199). 54 int limit; member in struct:max197_data 103 data->limit : data->limit / 2; max197_show_range() 126 int half = data->limit / 2; max197_store_range() 127 int full = data->limit; max197_store_range() 285 data->limit = MAX197_LIMIT; max197_probe() 288 data->limit = MAX199_LIMIT; max197_probe()
|
H A D | tmp401.c | 31 * and thus has 16 bits registers for its value and limit instead of 8 bits. 67 { 0x06, 0x08 }, /* low limit */ 68 { 0x05, 0x07 }, /* high limit */ 69 { 0x20, 0x19 }, /* therm (crit) limit */ 76 { 0x0C, 0x0E }, /* low limit */ 77 { 0x0B, 0x0D }, /* high limit */ 78 { 0x20, 0x19 }, /* therm (crit) limit */ 85 { 0x17, 0x14 }, /* low limit */ 86 { 0x16, 0x13 }, /* high limit */ 87 { 0, 0 }, /* therm (crit) limit (unused) */ 94 { 0x06, 0x08, 0x16 }, /* low limit */ 95 { 0x05, 0x07, 0x15 }, /* high limit */ 96 { 0x20, 0x19, 0x1A }, /* therm (crit) limit */ 101 { 0x0C, 0x0E, 0x16 }, /* low limit */ 102 { 0x0B, 0x0D, 0x15 }, /* high limit */ 103 { 0x20, 0x19, 0x1A }, /* therm (crit) limit */ 108 { 0x3E, 0x14, 0x18 }, /* low limit */ 109 { 0x3D, 0x13, 0x17 }, /* high limit */
|
H A D | max16065.c | 40 * l: limit 95 int limit[MAX16065_NUM_LIMIT][MAX16065_NUM_ADC]; member in struct:max16065_data 115 static inline int LIMIT_TO_MV(int limit, int range) LIMIT_TO_MV() argument 117 return limit * range / 256; LIMIT_TO_MV() 230 int limit; max16065_set_limit() local 236 limit = MV_TO_LIMIT(val, data->range[attr2->index]); max16065_set_limit() 239 data->limit[attr2->nr][attr2->index] max16065_set_limit() 240 = LIMIT_TO_MV(limit, data->range[attr2->index]); max16065_set_limit() 243 limit); max16065_set_limit() 256 data->limit[attr2->nr][attr2->index]); max16065_show_limit() 615 data->limit[i][j] = LIMIT_TO_MV(val, data->range[j]); max16065_probe()
|
H A D | emc1403.c | 116 unsigned int limit; show_hyst_common() local 120 retval = regmap_read(regmap, sda->index, &limit); show_hyst_common() 128 return sprintf(buf, "%d000\n", is_min ? limit + hyst : limit - hyst); show_hyst_common() 149 unsigned int limit; store_hyst() local 158 retval = regmap_read(regmap, sda->index, &limit); store_hyst() 162 hyst = limit * 1000 - val; store_hyst() 410 case 0x35: /* high limit status */ emc1403_regmap_is_volatile() 411 case 0x36: /* low limit status */ emc1403_regmap_is_volatile() 412 case 0x37: /* therm limit status */ emc1403_regmap_is_volatile()
|
H A D | nct7802.c | 132 if (ret == 0x1fff) /* maximum value, assume no limit */ nct7802_read_fan_min() 142 u8 reg_fan_high, unsigned int limit) nct7802_write_fan_min() 146 if (limit) nct7802_write_fan_min() 147 limit = DIV_ROUND_CLOSEST(1350000U, limit); nct7802_write_fan_min() 149 limit = 0x1fff; nct7802_write_fan_min() 150 limit = clamp_val(limit, 0, 0x1fff); nct7802_write_fan_min() 153 err = regmap_write(data->regmap, reg_fan_low, limit & 0xff); nct7802_write_fan_min() 157 err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5); nct7802_write_fan_min() 179 } else { /* limit */ nct7802_read_voltage() 141 nct7802_write_fan_min(struct nct7802_data *data, u8 reg_fan_low, u8 reg_fan_high, unsigned int limit) nct7802_write_fan_min() argument
|
/linux-4.1.27/drivers/gpu/drm/exynos/ |
H A D | regs-rotator.h | 67 /* Minimum limit value */ 69 /* Maximum limit value */
|
H A D | exynos_drm_rotator.c | 171 struct rot_limit *limit; rotator_align_size() local 174 /* Get size limit */ rotator_align_size() 176 limit = &limit_tbl->rgb888; rotator_align_size() 178 limit = &limit_tbl->ycbcr420_2p; rotator_align_size() 181 mask = ~((1 << limit->align) - 1); rotator_align_size() 184 val = ROT_ALIGN(*hsize, limit->align, mask); rotator_align_size() 185 if (val < limit->min_w) rotator_align_size() 186 *hsize = ROT_MIN(limit->min_w, mask); rotator_align_size() 187 else if (val > limit->max_w) rotator_align_size() 188 *hsize = ROT_MAX(limit->max_w, mask); rotator_align_size() 193 val = ROT_ALIGN(*vsize, limit->align, mask); rotator_align_size() 194 if (val < limit->min_h) rotator_align_size() 195 *vsize = ROT_MIN(limit->min_h, mask); rotator_align_size() 196 else if (val > limit->max_h) rotator_align_size() 197 *vsize = ROT_MAX(limit->max_h, mask); rotator_align_size()
|
/linux-4.1.27/arch/x86/math-emu/ |
H A D | get_address.c | 139 unsigned long base_address, limit, address, seg_top; pm_address() local 163 limit = base_address pm_address() 165 if (limit < base_address) pm_address() 166 limit = 0xffffffff; pm_address() 177 (address <= limit) || (address >= seg_top) ? 0 : pm_address() 181 (address > limit) || (address < base_address) ? 0 : pm_address() 182 ((limit - address) >= 254 ? 255 : limit - address + 1); pm_address()
|
/linux-4.1.27/include/uapi/asm-generic/ |
H A D | resource.h | 5 * Resource limit IDs 38 # define RLIMIT_AS 9 /* address space limit */
|
/linux-4.1.27/include/linux/mfd/pcf50633/ |
H A D | backlight.h | 27 * Brightness limit to be used after the driver has been probed. This is useful 48 int pcf50633_bl_set_brightness_limit(struct pcf50633 *pcf, unsigned int limit);
|
/linux-4.1.27/drivers/staging/speakup/ |
H A D | selection.c | 47 static unsigned short limit(const unsigned short v, const unsigned short u) limit() function 59 spk_xs = limit(spk_xs, vc->vc_cols - 1); speakup_set_selection() 60 spk_ys = limit(spk_ys, vc->vc_rows - 1); speakup_set_selection() 61 spk_xe = limit(spk_xe, vc->vc_cols - 1); speakup_set_selection() 62 spk_ye = limit(spk_ye, vc->vc_rows - 1); speakup_set_selection()
|
/linux-4.1.27/drivers/usb/host/ |
H A D | xhci-ext-caps.h | 138 * This uses an arbitrary limit of XHCI_MAX_EXT_CAPS extended capabilities 144 int limit = XHCI_MAX_EXT_CAPS; xhci_find_ext_cap_by_id() local 146 while (ext_offset && limit > 0) { xhci_find_ext_cap_by_id() 151 limit--; xhci_find_ext_cap_by_id() 153 if (limit > 0) xhci_find_ext_cap_by_id()
|
/linux-4.1.27/drivers/cpufreq/ |
H A D | e_powersaver.c | 190 unsigned int limit; eps_cpu_init() local 297 /* Check for ACPI processor speed limit */ eps_cpu_init() 299 if (!acpi_processor_get_bios_limit(policy->cpu, &limit)) { eps_cpu_init() 300 printk(KERN_INFO "eps: ACPI limit %u.%uGHz\n", eps_cpu_init() 301 limit/1000000, eps_cpu_init() 302 (limit%1000000)/10000); eps_cpu_init() 305 if (limit && max_multiplier * fsb > limit) { eps_cpu_init() 345 centaur->bios_limit = limit; eps_cpu_init() 431 MODULE_PARM_DESC(ignore_acpi_limit, "Don't check ACPI's processor speed limit");
|
/linux-4.1.27/arch/powerpc/sysdev/ |
H A D | dart_iommu.c | 82 unsigned long limit; dart_tlb_invalidate_all() local 96 limit = 0; dart_tlb_invalidate_all() 105 while ((DART_IN(DART_CNTL) & inv_bit) && l < (1L << limit)) dart_tlb_invalidate_all() 107 if (l == (1L << limit)) { dart_tlb_invalidate_all() 108 if (limit < 4) { dart_tlb_invalidate_all() 109 limit++; dart_tlb_invalidate_all() 125 unsigned int l, limit; dart_tlb_invalidate_one() local 134 limit = 0; dart_tlb_invalidate_one() 137 while ((DART_IN(DART_CNTL) & DART_CNTL_U4_IONE) && l < (1L << limit)) { dart_tlb_invalidate_one() 142 if (l == (1L << limit)) { dart_tlb_invalidate_one() 143 if (limit < 4) { dart_tlb_invalidate_one() 144 limit++; dart_tlb_invalidate_one() 462 * 1GB of RAM is picked as limit because some default devices alloc_dart_table()
|
/linux-4.1.27/lib/xz/ |
H A D | xz_dec_lzma2.c | 33 * pos <= limit <= end 60 /* Write limit; we don't write to buf[limit] or later bytes. */ 61 size_t limit; member in struct:dictionary 295 dict->limit = 0; dict_reset() 299 /* Set dictionary write limit */ dict_limit() 303 dict->limit = dict->end; dict_limit() 305 dict->limit = dict->pos + out_max; dict_limit() 311 return dict->pos < dict->limit; dict_has_space() 354 left = min_t(size_t, dict->limit - dict->pos, *len); dict_repeat() 520 uint16_t *probs, uint32_t limit) rc_bittree() 529 } while (symbol < limit); rc_bittree() 537 uint32_t *dest, uint32_t limit) rc_bittree_reverse() 549 } while (++i < limit); rc_bittree_reverse() 553 static inline void rc_direct(struct rc_dec *rc, uint32_t *dest, uint32_t limit) rc_direct() argument 564 } while (--limit > 0); rc_direct() 623 uint32_t limit; lzma_len() local 627 limit = LEN_LOW_SYMBOLS; lzma_len() 632 limit = LEN_MID_SYMBOLS; lzma_len() 636 limit = LEN_HIGH_SYMBOLS; lzma_len() 642 s->lzma.len += rc_bittree(&s->rc, probs, limit) - limit; lzma_len() 650 uint32_t limit; lzma_match() local 666 limit = (dist_slot >> 1) - 1; lzma_match() 670 s->lzma.rep0 <<= limit; lzma_match() 674 &s->lzma.rep0, limit); lzma_match() 676 rc_direct(&s->rc, &s->lzma.rep0, limit - ALIGN_BITS); lzma_match() 835 * The LZMA decoder assumes that if the input limit (s->rc.in_limit) hasn't 1062 * Set dictionary limit to indicate how much we want xz_dec_lzma2_run() 519 rc_bittree(struct rc_dec *rc, uint16_t *probs, uint32_t limit) rc_bittree() argument 535 rc_bittree_reverse(struct rc_dec *rc, uint16_t *probs, uint32_t *dest, uint32_t limit) rc_bittree_reverse() argument
|
/linux-4.1.27/drivers/staging/rtl8188eu/core/ |
H A D | rtw_efuse.c | 232 u16 limit = *size; efuse_read_phymap_from_txpktbuf() local 271 limit = (len-2 < limit) ? len-2 : limit; efuse_read_phymap_from_txpktbuf() 275 memcpy(pos, ((u8 *)&lo32)+2, (limit >= count+2) ? 2 : limit-count); efuse_read_phymap_from_txpktbuf() 276 count += (limit >= count+2) ? 2 : limit-count; efuse_read_phymap_from_txpktbuf() 280 memcpy(pos, ((u8 *)&lo32), (limit >= count+4) ? 4 : limit-count); efuse_read_phymap_from_txpktbuf() 281 count += (limit >= count+4) ? 4 : limit-count; efuse_read_phymap_from_txpktbuf() 285 if (limit > count && len-2 > count) { efuse_read_phymap_from_txpktbuf() 286 memcpy(pos, (u8 *)&hi32, (limit >= count+4) ? 4 : limit-count); efuse_read_phymap_from_txpktbuf() 287 count += (limit >= count+4) ? 4 : limit-count; efuse_read_phymap_from_txpktbuf() 291 if (limit <= count || len-2 <= count) efuse_read_phymap_from_txpktbuf()
|
/linux-4.1.27/drivers/net/ethernet/intel/i40e/ |
H A D | i40e_hmc.h | 167 * I40E_FIND_SD_INDEX_LIMIT - finds segment descriptor index limit 175 * This function calculates the segment descriptor index and index limit 186 /* add one more to the limit to correct our range */ \ 191 * I40E_FIND_PD_INDEX_LIMIT - finds page descriptor index limit 197 * @pd_limit: pointer to return page descriptor index limit 199 * Calculates the page descriptor index and index limit for the resource 210 /* add one more to the limit to correct our range */ \
|
/linux-4.1.27/drivers/net/ethernet/intel/i40evf/ |
H A D | i40e_hmc.h | 167 * I40E_FIND_SD_INDEX_LIMIT - finds segment descriptor index limit 175 * This function calculates the segment descriptor index and index limit 186 /* add one more to the limit to correct our range */ \ 191 * I40E_FIND_PD_INDEX_LIMIT - finds page descriptor index limit 197 * @pd_limit: pointer to return page descriptor index limit 199 * Calculates the page descriptor index and index limit for the resource 210 /* add one more to the limit to correct our range */ \
|
/linux-4.1.27/drivers/char/tpm/ |
H A D | tpm_eventlog.c | 77 void *limit = log->bios_event_log_end; tpm_bios_measurements_start() local 84 if ((addr + sizeof(struct tcpa_event)) < limit) { tpm_bios_measurements_start() 92 if ((addr + sizeof(struct tcpa_event)) >= limit) tpm_bios_measurements_start() 98 ((addr + sizeof(struct tcpa_event) + event->event_size) >= limit)) tpm_bios_measurements_start() 109 void *limit = log->bios_event_log_end; tpm_bios_measurements_next() local 114 if ((v + sizeof(struct tcpa_event)) >= limit) tpm_bios_measurements_next() 123 ((v + sizeof(struct tcpa_event) + event->event_size) >= limit)) tpm_bios_measurements_next()
|
/linux-4.1.27/include/acpi/ |
H A D | processor.h | 178 struct acpi_processor_lx state; /* current limit */ 179 struct acpi_processor_lx thermal; /* thermal limit */ 180 struct acpi_processor_lx user; /* user limit */ 187 u8 limit:1; member in struct:acpi_processor_flags 210 struct acpi_processor_limit limit; member in struct:acpi_processor 282 extern int acpi_processor_get_bios_limit(int cpu, unsigned int *limit); 305 static inline int acpi_processor_get_bios_limit(int cpu, unsigned int *limit) acpi_processor_get_bios_limit() argument
|
/linux-4.1.27/drivers/net/ethernet/ibm/emac/ |
H A D | phy.c | 57 int limit = 10000; emac_mii_reset_phy() local 66 while (--limit) { emac_mii_reset_phy() 72 if ((val & BMCR_ISOLATE) && limit > 0) emac_mii_reset_phy() 75 return limit <= 0; emac_mii_reset_phy() 81 int limit = 10000; emac_mii_reset_gpcs() local 90 while (--limit) { emac_mii_reset_gpcs() 96 if ((val & BMCR_ISOLATE) && limit > 0) emac_mii_reset_gpcs() 99 if (limit > 0 && phy->mode == PHY_MODE_SGMII) { emac_mii_reset_gpcs() 106 return limit <= 0; emac_mii_reset_gpcs()
|
/linux-4.1.27/arch/sparc/prom/ |
H A D | bootstr_64.c | 17 /* We limit BARG_LEN to 1024 because this is the size of the
|
/linux-4.1.27/drivers/gpu/drm/nouveau/nvkm/subdev/ltc/ |
H A D | base.c | 51 const u32 limit = first + count - 1; nvkm_ltc_tags_clear() local 53 BUG_ON((first > limit) || (limit >= priv->num_tags)); nvkm_ltc_tags_clear() 55 impl->cbc_clear(priv, first, limit); nvkm_ltc_tags_clear()
|
/linux-4.1.27/include/linux/platform_data/ |
H A D | voltage-omap.h | 20 * @sr_errminlimit: Error min limit value for smartreflex. This value
|
/linux-4.1.27/arch/powerpc/include/asm/ |
H A D | kdump.h | 8 /* How many bytes to reserve at zero for kdump. The reserve limit should
|
/linux-4.1.27/net/bridge/netfilter/ |
H A D | ebt_among.c | 27 int start, limit, i; ebt_mac_wormhash_contains() local 33 limit = wh->table[key + 1]; ebt_mac_wormhash_contains() 35 for (i = start; i < limit; i++) { ebt_mac_wormhash_contains() 42 for (i = start; i < limit; i++) { ebt_mac_wormhash_contains()
|
H A D | ebt_limit.c | 102 .name = "limit", 126 MODULE_DESCRIPTION("Ebtables: Rate-limit match");
|
/linux-4.1.27/include/linux/ceph/ |
H A D | mdsmap.h | 10 * we limit fields to those the client actually xcares about
|
/linux-4.1.27/include/linux/mfd/wm831x/ |
H A D | pdata.h | 29 int vlim; /** Voltage limit in millivolts */ 30 int ilim; /** Current limit in microamps */ 37 int trickle_ilim; /** Trickle charge current limit, in mA */ 40 int fast_ilim; /** Fast charge current limit, in mA */
|
/linux-4.1.27/drivers/ata/ |
H A D | pata_amd.c | 277 unsigned long bios_limit = 0, acpi_limit = 0, limit; nv_mode_filter() local 300 limit = bios_limit | acpi_limit; nv_mode_filter() 302 /* If PIO or DMA isn't configured at all, don't limit. Let EH nv_mode_filter() 305 if (!(limit & ATA_MASK_PIO)) nv_mode_filter() 306 limit |= ATA_MASK_PIO; nv_mode_filter() 307 if (!(limit & (ATA_MASK_MWDMA | ATA_MASK_UDMA))) nv_mode_filter() 308 limit |= ATA_MASK_MWDMA | ATA_MASK_UDMA; nv_mode_filter() 311 limit |= ata_pack_xfermask(ATA_PIO4, ATA_MWDMA2, ATA_UDMA2); nv_mode_filter() 315 xfer_mask, limit, xfer_mask & limit, bios_limit, nv_mode_filter() 318 return xfer_mask & limit; nv_mode_filter()
|
/linux-4.1.27/drivers/isdn/mISDN/ |
H A D | l1oip.h | 60 int limit; /* limit number of bchannels */ member in struct:l1oip
|
/linux-4.1.27/drivers/media/dvb-frontends/ |
H A D | lnbp21.h | 33 /* [RO] 0=OK; 1=over current limit flag */ 49 /* [RW] current limit select:
|
/linux-4.1.27/drivers/power/ |
H A D | pcf50633-charger.c | 73 * We limit the charging current to be the USB current limit. pcf50633_mbc_usb_curlim_set() 75 * which it does when the device goes "off", the USB current limit pcf50633_mbc_usb_curlim_set() 78 * as the USB limit we set here before PMU standby, we enforce it only pcf50633_mbc_usb_curlim_set() 79 * using the correct amount of current even when the USB current limit pcf50633_mbc_usb_curlim_set() 244 * This attribute allows to change MBC charging limit on the fly 245 * independently of usb current limit. It also gets set automatically every 246 * time usb current limit is changed.
|
/linux-4.1.27/security/keys/ |
H A D | gc.c | 189 time_t new_timer, limit; key_garbage_collector() local 193 limit = current_kernel_time().tv_sec; key_garbage_collector() 194 if (limit > key_gc_delay) key_garbage_collector() 195 limit -= key_gc_delay; key_garbage_collector() 197 limit = key_gc_delay; key_garbage_collector() 236 if (key->expiry > limit && key->expiry < new_timer) { key_garbage_collector() 238 key_serial(key), key->expiry - limit); key_garbage_collector() 344 keyring_gc(key, limit); key_garbage_collector()
|
/linux-4.1.27/tools/testing/selftests/vm/ |
H A D | hugepage-shm.c | 17 * Note: The default shared memory limit is quite low on many kernels, 23 * The other limit that you will hit eventually is shmall which is the
|
/linux-4.1.27/include/linux/mfd/wm8350/ |
H A D | supply.h | 116 int fast_limit_mA; /* fast charge current limit */ 117 int fast_limit_USB_mA; /* USB fast charge current limit */
|
/linux-4.1.27/drivers/net/fddi/skfp/ |
H A D | smtdef.c | 77 static int set_min_max(int maxflag, u_long mib, u_long limit, u_long *oper); 339 * if limit is lower than mib 340 * use limit 345 static int set_min_max(int maxflag, u_long mib, u_long limit, u_long *oper) set_min_max() argument 349 if ((limit > mib) ^ maxflag) set_min_max() 350 *oper = limit ; set_min_max()
|
/linux-4.1.27/fs/freevxfs/ |
H A D | vxfs_lookup.c | 135 caddr_t baddr, limit; vxfs_find_entry() local 140 limit = baddr + bsize - VXFS_DIRLEN(1); vxfs_find_entry() 145 for (; (caddr_t)de <= limit; de = vxfs_next_entry(de)) { vxfs_find_entry() 279 char *baddr, *limit; vxfs_readdir() local 284 limit = baddr + bsize - VXFS_DIRLEN(1); vxfs_readdir() 292 for (; (char *)de <= limit; de = vxfs_next_entry(de)) { vxfs_readdir()
|
/linux-4.1.27/tools/perf/util/ |
H A D | ordered-events.c | 126 pr("allocation limit reached %" PRIu64 "B\n", oe->max_alloc_size); alloc_event() 189 u64 limit = oe->next_flush; __ordered_events__flush() local 191 bool show_progress = limit == ULLONG_MAX; __ordered_events__flush() 195 if (!limit) __ordered_events__flush() 205 if (iter->timestamp > limit) list_for_each_entry_safe() 220 else if (last_ts <= limit)
|
/linux-4.1.27/arch/arm64/mm/ |
H A D | mmu.c | 347 phys_addr_t limit; map_mem() local 350 * Temporarily limit the memblock range. We need to do this as map_mem() 360 limit = PHYS_OFFSET + PMD_SIZE; map_mem() 362 limit = PHYS_OFFSET + PUD_SIZE; map_mem() 363 memblock_set_current_limit(limit); map_mem() 376 * current memblock limit to prevent create_mapping() from for_each_memblock() 381 if (start < limit) for_each_memblock() 383 if (end < limit) { for_each_memblock() 384 limit = end & PMD_MASK; for_each_memblock() 385 memblock_set_current_limit(limit); for_each_memblock()
|
/linux-4.1.27/drivers/infiniband/hw/qib/ |
H A D | qib_diag.c | 258 /* If user regs mapped, they are after send, so set limit. */ qib_remap_ioaddr32() 288 * appropriate limit. qib_remap_ioaddr32() 344 u32 limit; qib_read_umem64() local 347 reg_addr = (const u64 __iomem *)qib_remap_ioaddr32(dd, regoffs, &limit); qib_read_umem64() 348 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) { qib_read_umem64() 352 if (count >= limit) qib_read_umem64() 353 count = limit; qib_read_umem64() 388 u32 limit; qib_write_umem64() local 391 reg_addr = (u64 __iomem *)qib_remap_ioaddr32(dd, regoffs, &limit); qib_write_umem64() 392 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) { qib_write_umem64() 396 if (count >= limit) qib_write_umem64() 397 count = limit; qib_write_umem64() 433 u32 limit; qib_read_umem32() local 436 reg_addr = qib_remap_ioaddr32(dd, regoffs, &limit); qib_read_umem32() 437 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) { qib_read_umem32() 441 if (count >= limit) qib_read_umem32() 442 count = limit; qib_read_umem32() 479 u32 limit; qib_write_umem32() local 482 reg_addr = qib_remap_ioaddr32(dd, regoffs, &limit); qib_write_umem32() 483 if (reg_addr == NULL || limit == 0 || !(dd->flags & QIB_PRESENT)) { qib_write_umem32() 487 if (count >= limit) qib_write_umem32() 488 count = limit; qib_write_umem32()
|
/linux-4.1.27/drivers/staging/fwserial/ |
H A D | dma_fifo.c | 193 unsigned len, n, ofs, l, limit; dma_fifo_out_pend() local 213 limit = min_t(unsigned, l, fifo->tx_limit); dma_fifo_out_pend() 214 if (n > limit) { dma_fifo_out_pend() 215 n = limit; dma_fifo_out_pend() 216 fifo->out += limit; dma_fifo_out_pend() 235 "past open limit:%d (limit:%d)", dma_fifo_out_pend()
|
/linux-4.1.27/drivers/net/ethernet/intel/ixgbe/ |
H A D | ixgbe_lib.c | 329 u16 vmdq_i = adapter->ring_feature[RING_F_VMDQ].limit; ixgbe_set_dcb_sriov_queues() 391 /* limit ourselves based on feature limits */ ixgbe_set_dcb_sriov_queues() 392 fcoe_i = min_t(u16, fcoe_i, fcoe->limit); ixgbe_set_dcb_sriov_queues() 436 /* determine the upper limit for our current DCB mode */ ixgbe_set_dcb_queues() 454 rss_i = min_t(int, rss_i, f->limit); ixgbe_set_dcb_queues() 471 f->indices = min_t(u16, rss_i, f->limit); ixgbe_set_dcb_queues() 497 u16 vmdq_i = adapter->ring_feature[RING_F_VMDQ].limit; ixgbe_set_sriov_queues() 499 u16 rss_i = adapter->ring_feature[RING_F_RSS].limit; ixgbe_set_sriov_queues() 540 /* limit RSS based on user input and save for later use */ ixgbe_set_sriov_queues() 564 /* limit ourselves based on feature limits */ ixgbe_set_sriov_queues() 565 fcoe_i = min_t(u16, fcoe_i, fcoe->limit); ixgbe_set_sriov_queues() 575 /* limit indices to rss_i if MSI-X is disabled */ ixgbe_set_sriov_queues() 580 fcoe->indices = min_t(u16, fcoe_i, fcoe->limit); ixgbe_set_sriov_queues() 608 /* set mask for 16 queue limit of RSS */ ixgbe_set_rss_queues() 610 rss_i = f->limit; ixgbe_set_rss_queues() 626 rss_i = f->indices = f->limit; ixgbe_set_rss_queues() 648 fcoe_i = min_t(u16, f->limit + rss_i, num_online_cpus()); ixgbe_set_rss_queues() 651 /* limit indices to rss_i if MSI-X is disabled */ ixgbe_set_rss_queues() 656 f->indices = min_t(u16, fcoe_i, f->limit); ixgbe_set_rss_queues() 731 * exceeds our vector limit ixgbe_acquire_msix_vectors() 1129 adapter->ring_feature[RING_F_RSS].limit = 1; ixgbe_set_interrupt_capability()
|
/linux-4.1.27/drivers/ssb/ |
H A D | driver_chipcommon.c | 152 int uninitialized_var(limit); chipco_pctl_clockfreqlimit() 189 limit = 43000; chipco_pctl_clockfreqlimit() 191 limit = 25000; chipco_pctl_clockfreqlimit() 195 limit = 20200000; chipco_pctl_clockfreqlimit() 197 limit = 19800000; chipco_pctl_clockfreqlimit() 201 limit = 34000000; chipco_pctl_clockfreqlimit() 203 limit = 25000000; chipco_pctl_clockfreqlimit() 206 limit /= divisor; chipco_pctl_clockfreqlimit() 208 return limit; chipco_pctl_clockfreqlimit()
|
/linux-4.1.27/fs/exofs/ |
H A D | dir.c | 94 unsigned limit = PAGE_CACHE_SIZE; exofs_check_page() local 100 limit = dir->i_size & ~PAGE_CACHE_MASK; exofs_check_page() 101 if (limit & (chunk_size - 1)) exofs_check_page() 103 if (!limit) exofs_check_page() 106 for (offs = 0; offs <= limit - EXOFS_DIR_REC_LEN(1); offs += rec_len) { exofs_check_page() 119 if (offs != limit) exofs_check_page() 256 char *kaddr, *limit; exofs_readdir() local 277 limit = kaddr + exofs_last_byte(inode, n) - exofs_readdir() 279 for (; (char *)de <= limit; de = exofs_next_entry(de)) { exofs_readdir()
|
/linux-4.1.27/drivers/thermal/ |
H A D | step_wise.c | 36 * c. if the trend is THERMAL_TREND_RAISE_FULL, use upper limit 38 * d. if the trend is THERMAL_TREND_DROP_FULL, use lower limit 44 * equals lower limit, deactivate the thermal instance 46 * d. if the trend is THERMAL_TREND_DROP_FULL, use lower limit, 47 * if the cooling state already equals lower limit,
|
/linux-4.1.27/drivers/tty/vt/ |
H A D | selection.c | 123 static inline unsigned short limit(const unsigned short v, const unsigned short u) limit() function 180 xs = limit(xs, vc->vc_cols - 1); set_selection() 181 ys = limit(ys, vc->vc_rows - 1); set_selection() 182 xe = limit(xe, vc->vc_cols - 1); set_selection() 183 ye = limit(ye, vc->vc_rows - 1); set_selection()
|
/linux-4.1.27/drivers/usb/isp1760/ |
H A D | isp1760-if.c | 34 u8 latency, limit; isp1761_pci_init() local 62 pci_read_config_byte(dev, PCI_MAX_LAT, &limit); isp1761_pci_init() 63 if (limit && limit < latency) isp1761_pci_init() 64 pci_write_config_byte(dev, PCI_LATENCY_TIMER, limit); isp1761_pci_init()
|
/linux-4.1.27/drivers/infiniband/hw/mlx5/ |
H A D | mr.c | 234 if (var < ent->limit) size_write() 303 ent->limit = var; limit_write() 305 if (ent->cur < ent->limit) { limit_write() 306 err = add_keys(dev, c, 2 * ent->limit - ent->cur); limit_write() 324 err = snprintf(lbuf, sizeof(lbuf), "%d\n", ent->limit); limit_read() 348 if (cache->ent[i].cur < cache->ent[i].limit) someone_adding() 366 if (ent->cur < 2 * ent->limit && !dev->fill_delay) { __cache_work_func() 368 if (ent->cur < 2 * ent->limit) { __cache_work_func() 383 } else if (ent->cur > 2 * ent->limit) { __cache_work_func() 387 if (ent->cur > ent->limit) __cache_work_func() 437 if (ent->cur < ent->limit) alloc_cached_mr() 471 if (ent->cur > 2 * ent->limit) free_cached_mr() 531 ent->flimit = debugfs_create_file("limit", 0600, ent->dir, ent, mlx5_mr_cache_debugfs_init() 569 int limit; mlx5_mr_cache_init() local 591 limit = dev->mdev->profile->mr_cache[i].limit; mlx5_mr_cache_init() 593 limit = 0; mlx5_mr_cache_init() 597 ent->limit = limit; mlx5_mr_cache_init()
|
/linux-4.1.27/drivers/mmc/host/ |
H A D | cb710-mmc.c | 149 unsigned limit = 2000000; /* FIXME: real timeout */ cb710_wait_for_event() local 157 if (!--limit) { cb710_wait_for_event() 169 limit = 2000000 - limit; cb710_wait_for_event() 170 if (limit > 100) cb710_wait_for_event() 173 limit, what, e, x); cb710_wait_for_event() local 181 unsigned limit = 500000; /* FIXME: real timeout */ cb710_wait_while_busy() local 190 if (!--limit) { cb710_wait_while_busy() 202 limit = 500000 - limit; cb710_wait_while_busy() 203 if (limit > 100) cb710_wait_while_busy() 206 limit, mask, e, x); cb710_wait_while_busy() local
|
/linux-4.1.27/drivers/net/wireless/rt2x00/ |
H A D | rt2x00mmio.c | 123 queue->limit * queue->desc_size, &dma, rt2x00mmio_alloc_queue_dma() 131 for (i = 0; i < queue->limit; i++) { rt2x00mmio_alloc_queue_dma() 148 queue->limit * queue->desc_size, rt2x00mmio_free_queue_dma()
|
/linux-4.1.27/drivers/input/serio/ |
H A D | apbps2.c | 109 int limit; apbps2_open() local 116 limit = 1024; apbps2_open() 117 while ((ioread32be(&priv->regs->status) & APBPS2_STATUS_DR) && --limit) apbps2_open()
|
/linux-4.1.27/drivers/tty/ |
H A D | tty_buffer.c | 25 * Byte threshold to limit memory consumption for flip buffers. 26 * The actual memory limit is > 2x this amount. 83 * reaching the buffer limit. 531 * tty_buffer_set_limit - change the tty buffer memory limit 534 * Change the tty buffer memory limit. 538 int tty_buffer_set_limit(struct tty_port *port, int limit) tty_buffer_set_limit() argument 540 if (limit < MIN_TTYB_SIZE) tty_buffer_set_limit() 542 port->buf.mem_limit = limit; tty_buffer_set_limit()
|
/linux-4.1.27/drivers/watchdog/ |
H A D | cpwd.c | 104 * dcntr and limit registers (halfword access): 113 * 'limit' value. 114 * limit - 16-bit countdown value in 1/10th second increments. 117 * NOTES: After watchdog reset, dcntr and limit contain '1' 219 /* Restarts timer with maximum limit value and 258 /* Reset countdown timer with 'limit' value and continue countdown. 283 /* Start a watchdog timer with the specified limit value 285 * the provided limit value.
|
/linux-4.1.27/arch/s390/include/asm/ |
H A D | pgalloc.h | 59 int crst_table_upgrade(struct mm_struct *, unsigned long limit); 60 void crst_table_downgrade(struct mm_struct *, unsigned long limit);
|
/linux-4.1.27/arch/ia64/include/asm/sn/ |
H A D | arch.h | 30 * Note: ACPI20 has an architectural limit of 256 nodes. When we upgrade 31 * to ACPI3.0, this limit will be removed. The notion of "compact nodes"
|
/linux-4.1.27/tools/testing/selftests/mqueue/ |
H A D | mq_open_tests.c | 439 printf("Queue open with mq_maxmsg > limit when euid = 0 " main() 442 printf("Queue open with mq_maxmsg > limit when euid = 0 " main() 447 printf("Queue open with mq_msgsize > limit when euid = 0 " main() 450 printf("Queue open with mq_msgsize > limit when euid = 0 " main() 477 printf("Queue open with mq_maxmsg > limit when euid = 99 " main() 480 printf("Queue open with mq_maxmsg > limit when euid = 99 " main() 485 printf("Queue open with mq_msgsize > limit when euid = 99 " main() 488 printf("Queue open with mq_msgsize > limit when euid = 99 " main()
|
/linux-4.1.27/arch/ia64/sn/pci/ |
H A D | tioce_provider.c | 696 * @limit: last bus address to reserve 698 * If base/limit falls within the range of bus space mapped through the 702 tioce_reserve_m32(struct tioce_kernel *ce_kern, u64 base, u64 limit) tioce_reserve_m32() argument 710 last_ate = ate_index + ATE_NPAGES(base, limit-base+1, ps) - 1; tioce_reserve_m32() 793 * Memory space covered by each PPB mem base/limit register tioce_kern_init() 794 * Memory space covered by each PPB prefetch base/limit register tioce_kern_init() 801 u64 base, limit; tioce_kern_init() local 803 /* mem base/limit */ tioce_kern_init() 811 limit = (u64)tmp << 16; tioce_kern_init() 812 limit |= 0xfffffUL; tioce_kern_init() 814 if (base < limit) tioce_kern_init() 815 tioce_reserve_m32(tioce_kern, base, limit); tioce_kern_init() 818 * prefetch mem base/limit. The tioce ppb's have 64-bit tioce_kern_init() 834 limit = ((u64)tmp & PCI_PREF_RANGE_MASK) << 16; tioce_kern_init() 835 limit |= 0xfffffUL; tioce_kern_init() 839 limit |= (u64)tmp << 32; tioce_kern_init() 841 if ((base < limit) && TIOCE_M32_ADDR(base)) tioce_kern_init() 842 tioce_reserve_m32(tioce_kern, base, limit); tioce_kern_init()
|
/linux-4.1.27/drivers/net/ethernet/mellanox/mlx5/core/ |
H A D | main.c | 93 .limit = 250 97 .limit = 250 101 .limit = 250 105 .limit = 250 109 .limit = 250 113 .limit = 250 117 .limit = 250 121 .limit = 250 125 .limit = 250 129 .limit = 250 133 .limit = 250 137 .limit = 250 141 .limit = 32 145 .limit = 16 149 .limit = 8 153 .limit = 4 437 /* we limit the size of the pkey table to 128 entries for now */ handle_hca_cap()
|
/linux-4.1.27/arch/powerpc/platforms/pseries/ |
H A D | iommu.c | 191 long l, limit; tce_buildmulti_pSeriesLP() local 230 limit = min_t(long, npages, 4096/TCE_ENTRY_SIZE); tce_buildmulti_pSeriesLP() 232 for (l = 0; l < limit; l++) { tce_buildmulti_pSeriesLP() 240 limit); tce_buildmulti_pSeriesLP() 242 npages -= limit; tce_buildmulti_pSeriesLP() 243 tcenum += limit; tce_buildmulti_pSeriesLP() 251 (npages_start - (npages + limit))); tce_buildmulti_pSeriesLP() 358 long limit; tce_clearrange_multi_pSeriesLP() local 378 limit = min_t(long, num_tce, 512); tce_clearrange_multi_pSeriesLP() 383 0, limit); tce_clearrange_multi_pSeriesLP() 384 next += limit * tce_size; tce_clearrange_multi_pSeriesLP() 385 num_tce -= limit; tce_clearrange_multi_pSeriesLP() 399 long l, limit; tce_setrange_multi_pSeriesLP() local 435 limit = min_t(long, num_tce, 4096/TCE_ENTRY_SIZE); tce_setrange_multi_pSeriesLP() 438 for (l = 0; l < limit; l++) { tce_setrange_multi_pSeriesLP() 446 limit); tce_setrange_multi_pSeriesLP() 448 num_tce -= limit; tce_setrange_multi_pSeriesLP()
|
/linux-4.1.27/drivers/hwmon/pmbus/ |
H A D | pmbus_core.c | 690 * other to determine if a limit has been exceeded. 696 * limit has to be performed to determine the boolean result. 700 * To determine if an object exceeds upper limits, specify <s1,s2> = <v,limit>. 701 * To determine if an object exceeds lower limits, specify <s1,s2> = <limit,v>. 938 * The pmbus_limit_attr structure describes a single limit attribute 945 bool low; /* True if low limit; for limits with compare 953 * description includes a reference to the associated limit attributes. 958 u8 nlimit; /* # of limit registers */ 967 const struct pmbus_limit_attr *limit;/* limit registers */ member in struct:pmbus_sensor_attr 971 * Add a set of limit attributes and, if supported, the associated 983 const struct pmbus_limit_attr *l = attr->limit; pmbus_add_limit_attrs() 1200 .limit = vin_limit_attrs, 1209 .limit = vmon_limit_attrs, 1225 .limit = vout_limit_attrs, 1303 .limit = iin_limit_attrs, 1314 .limit = iout_limit_attrs, 1379 .limit = pin_limit_attrs, 1389 .limit = pout_limit_attrs, 1509 .limit = temp_limit_attrs, 1521 .limit = temp_limit_attrs2, 1533 .limit = temp_limit_attrs3,
|
/linux-4.1.27/drivers/media/i2c/smiapp/ |
H A D | smiapp-quirk.c | 48 u32 limit, u32 val) smiapp_replace_limit() 53 smiapp_reg_limits[limit].addr, smiapp_replace_limit() 54 smiapp_reg_limits[limit].what, val, val); smiapp_replace_limit() 55 sensor->limits[limit] = val; smiapp_replace_limit() 47 smiapp_replace_limit(struct smiapp_sensor *sensor, u32 limit, u32 val) smiapp_replace_limit() argument
|
/linux-4.1.27/drivers/media/tuners/ |
H A D | tda18271-maps.c | 959 u16 limit; member in struct:tda18271_cid_target_map 963 { .rfmax = 46000, .target = 0x04, .limit = 1800 }, 964 { .rfmax = 52200, .target = 0x0a, .limit = 1500 }, 965 { .rfmax = 70100, .target = 0x01, .limit = 4000 }, 966 { .rfmax = 136800, .target = 0x18, .limit = 4000 }, 967 { .rfmax = 156700, .target = 0x18, .limit = 4000 }, 968 { .rfmax = 186250, .target = 0x0a, .limit = 4000 }, 969 { .rfmax = 230000, .target = 0x0a, .limit = 4000 }, 970 { .rfmax = 345000, .target = 0x18, .limit = 4000 }, 971 { .rfmax = 426000, .target = 0x0e, .limit = 4000 }, 972 { .rfmax = 489500, .target = 0x1e, .limit = 4000 }, 973 { .rfmax = 697500, .target = 0x32, .limit = 4000 }, 974 { .rfmax = 842000, .target = 0x3a, .limit = 4000 }, 975 { .rfmax = 0, .target = 0x00, .limit = 0 }, /* end */ 990 *count_limit = tda18271_cid_target[i].limit; tda18271_lookup_cid_target() 993 tda18271_cid_target[i].target, tda18271_cid_target[i].limit); tda18271_lookup_cid_target()
|
/linux-4.1.27/drivers/media/usb/gspca/m5602/ |
H A D | m5602_ov9650.h | 258 /* Set the AGC/AEC stable region upper limit */ 260 /* Set the AGC/AEC stable region lower limit */ 262 /* Set the high and low limit nibbles to 3 */ 266 limit exposure timing,
|
/linux-4.1.27/drivers/net/wireless/iwlwifi/ |
H A D | iwl-debug.h | 79 u32 level, bool limit, const char *function, 84 u32 level, bool limit, const char *function, __iwl_dbg() 95 #define __IWL_DEBUG_DEV(dev, level, limit, fmt, args...) \ 98 __iwl_dbg(dev, level, limit, __func__, fmt, ##args); \ 83 __iwl_dbg(struct device *dev, u32 level, bool limit, const char *function, const char *fmt, ...) __iwl_dbg() argument
|