Searched refs:limit (Results 1 - 200 of 2170) sorted by relevance

1234567891011

/linux-4.1.27/fs/quota/
H A Dquotaio_v1.h10 * 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 Dquotaio_v2.h39 __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 Damdtopology.c99 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 Dnuma_emulation.c129 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 Ddynamic_queue_limits.c16 /* 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 Diommu-helper.c26 /* We don't want the last of the limit */ iommu_area_alloc()
H A Dratelimit.c2 * ratelimit.c - Do something with rate limit.
21 * This enforces a rate limit: not more than @rs->burst callbacks
H A Ducs2_string.c86 unsigned long limit = ucs2_strnlen(src, maxlength); ucs2_as_utf8() local
88 for (i = 0; maxlength && i < limit; i++) { ucs2_as_utf8()
H A Diommu-common.c109 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 Dstrncpy_from_user.c29 * 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 Dstrnlen_user.c34 * 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 Ddecompress_bunzip2.c82 /* 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 Dsch_fifo.c24 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 Dsch_red.c29 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 Dsch_sfb.c65 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 Dsch_plug.c68 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 Dsch_pie.c43 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 Dsch_codel.c98 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 Dsch_tbf.c96 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 Dsch_sfq.c119 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 Dsch_choke.c53 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 Dmax1617.h12 #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 Debt_limit.h6 #define EBT_LIMIT_MATCH "limit"
16 __u32 burst; /* Period multiplier for upper limit. */
/linux-4.1.27/arch/arm64/lib/
H A Dmemcmp.S43 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 Dstrncmp.S47 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 Dstrnlen.S41 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 Dstmmac_hwtstamp.c56 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 Ddwmac100_dma.c39 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 Ddwmac1000_dma.c37 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 Duaccess.c20 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 Dpage_counter.c57 * @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 Dnobootmem.c36 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 Dbootmem.c495 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 Dcma.c214 * @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 Dip_set_bitmap.h8 /* The range exceeds the size limit of the set type */
/linux-4.1.27/arch/ia64/include/asm/
H A Dustack.h7 /* The absolute hard limit for stack size is 1/2 of the mappable space in the region */
H A Dmmu_context.h37 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 Dip6_tunnel.h9 /* 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 Ddqblk_xfs.h56 __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 Dmsg.h57 * 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 Dpkt_sched.h82 #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 Dgen_stats.h57 * @overlimits: number of enqueues over the limit
H A Dposix_types.h10 * one limit that doesn't have to be changed [again].
H A Dshm.h15 * "retrieve current limit; add X; update limit". It is therefore not
H A Dfalloc.h19 * 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 Dnf_conntrack_sip.c59 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 Dnft_limit.c97 .name = "limit",
120 MODULE_ALIAS_NFT_EXPR("limit");
/linux-4.1.27/arch/x86/um/asm/
H A Dmm_context.h38 ((((info)->base_addr & 0x0000ffff) << 16) | ((info)->limit & 0x0ffff))
43 ((info)->limit & 0xf0000) | \
54 (info)->limit == 0 && \
H A Ddesc.h8 (info)->limit == 0 && \
/linux-4.1.27/fs/xfs/
H A Dxfs_qm.h70 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 Dxfs_qm_bhv.c36 __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 Dxfs_pnfs.c124 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 Dpage_counter.h10 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 Ddynamic_queue_limits.h10 * 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 Dacpi_pmtmr.h9 /* limit it to 24 bits */
H A Dipc.h8 #define IPCMNI 32768 /* <= MAX_INT limit for ipc arrays (including sysctl changes) */
H A Ddma-contiguous.h86 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 Dcma.h23 phys_addr_t size, phys_addr_t limit,
H A Dthreads.h6 * The default limit for the nr of threads is now in
H A Dtty_flip.h4 extern int tty_buffer_set_limit(struct tty_port *port, int limit);
H A Dquota.h196 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 Dlops.h35 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 Dresource.h5 * 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 Dstorage.c135 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 Dkv_smc.c76 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 Dci_smc.c34 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 Dsi_smc.c34 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 Drv770_smc.c278 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 Drv770_smc.h192 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 Doaktrail_crtc.c46 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 Dgma_display.c700 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 Dgma_display.h58 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 Dpsb_intel_display.c68 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 Dcpu_type.h20 #define SUN4M_NCPUS 4 /* Architectural limit of sun4m. */
H A Dobio.h122 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 Dtimer_32.h25 * When a counter reaches the value in the corresponding limit register,
/linux-4.1.27/drivers/gpu/drm/nouveau/include/nvkm/engine/
H A Ddmaobj.h11 u64 limit; member in struct:nvkm_dmaobj
H A Dfalcon.h42 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 Dxt_connlimit.h24 unsigned int limit; member in struct:xt_connlimit_info
H A Dxt_limit.h15 __u32 burst; /* Period multiplier for upper limit. */
H A Dxt_u32.h25 * For now, I settle with a limit of 10 each.
H A Dxt_hashlimit.h30 __u32 burst; /* Period multiplier for upper limit. */
54 __u32 burst; /* Period multiplier for upper limit. */
/linux-4.1.27/fs/dlm/
H A Dmidcomms.h18 unsigned len, unsigned limit);
H A Dmidcomms.c35 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 Ddso-data.c231 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 Dpcf50633-backlight.c38 * 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 Dcalib.c50 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 Dsmb347-charger.h29 /* 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 Dio-unit.c52 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 Dnv50_fence.c42 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 Dnouveau_chan.c139 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 Dnv17_fence.c80 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 Dshadowacpi.c51 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 Dldt.h16 * 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 Dcheck.h20 int limit; member in struct:parsed_partitions
43 if (n < p->limit) { put_partition()
H A Dkarma.c45 if (slot == state->limit) karma_partition()
H A Datari.c66 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 Dmac.c67 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 Dresource.h14 * 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 Dresource.c42 * 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 Dresource.h11 * These two resource limit IDs have a Sparc/Linux-specific ordering,
/linux-4.1.27/arch/x86/include/asm/
H A Ddesc_defs.h32 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 Ddesc.h13 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 Dpage_32_types.h30 /* 44=32+12, the limit we can fit into an unsigned long pfn */
/linux-4.1.27/arch/microblaze/include/asm/
H A Ddma.h13 /* we don't have dma address limit. define it as zero to be
/linux-4.1.27/arch/mips/include/asm/
H A Dmips_mt.h11 * How many VPEs and TCs is Linux allowed to use? 0 means no limit.
/linux-4.1.27/arch/powerpc/mm/
H A Dsubpage-prot.c100 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 Dfsl_booke_mmu.c66 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 Dppc_mmu_32.c45 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 Dacornfb.h18 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 Dfalcon.c96 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 Dpaca.c49 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 Ditem.c69 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 Daw2-saa7146.c167 /* 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 Dclk-kona-setup.c31 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 Dnv50.c114 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 Ddma-contiguous.c100 * @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 Dsunhv.c78 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 Dbe.h48 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 Dbase.c82 "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 Dboard.c57 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 Djfs_types.h142 * 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 Dieee80211.c111 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 Dnv10.c33 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 Dnv20.c33 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 Dnv44.c34 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 Ddir.c104 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 Dnumachip.c19 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 Dtls.h13 unsigned int limit; member in struct:um_dup_user_desc
/linux-4.1.27/include/net/
H A Dip6_tunnel.h22 __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 Dpkt_sched.h83 int fifo_set_limit(struct Qdisc *q, unsigned int limit);
85 unsigned int limit);
/linux-4.1.27/include/uapi/linux/usb/
H A Dcdc-wdm.h16 * defining the message limit for both reading and writing.
/linux-4.1.27/net/appletalk/
H A Dsysctl_net_atalk.c29 .procname = "aarp-retransmit-limit",
/linux-4.1.27/drivers/usb/mon/
H A Dmon_text.c32 * 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 Dldlm_pool.c49 * 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 Dmax197.c46 * @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 Dtmp401.c31 * 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 Dmax16065.c40 * 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 Demc1403.c116 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 Dnct7802.c132 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 Dregs-rotator.h67 /* Minimum limit value */
69 /* Maximum limit value */
H A Dexynos_drm_rotator.c171 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 Dget_address.c139 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 Dresource.h5 * Resource limit IDs
38 # define RLIMIT_AS 9 /* address space limit */
/linux-4.1.27/include/linux/mfd/pcf50633/
H A Dbacklight.h27 * 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 Dselection.c47 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 Dxhci-ext-caps.h138 * 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 De_powersaver.c190 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 Ddart_iommu.c82 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 Dxz_dec_lzma2.c33 * 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 Drtw_efuse.c232 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 Di40e_hmc.h167 * 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 Di40e_hmc.h167 * 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 Dtpm_eventlog.c77 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 Dprocessor.h178 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 Dphy.c57 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 Dbootstr_64.c17 /* 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 Dbase.c51 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 Dvoltage-omap.h20 * @sr_errminlimit: Error min limit value for smartreflex. This value
/linux-4.1.27/arch/powerpc/include/asm/
H A Dkdump.h8 /* How many bytes to reserve at zero for kdump. The reserve limit should
/linux-4.1.27/net/bridge/netfilter/
H A Debt_among.c27 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 Debt_limit.c102 .name = "limit",
126 MODULE_DESCRIPTION("Ebtables: Rate-limit match");
/linux-4.1.27/include/linux/ceph/
H A Dmdsmap.h10 * we limit fields to those the client actually xcares about
/linux-4.1.27/include/linux/mfd/wm831x/
H A Dpdata.h29 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 Dpata_amd.c277 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 Dl1oip.h60 int limit; /* limit number of bchannels */ member in struct:l1oip
/linux-4.1.27/drivers/media/dvb-frontends/
H A Dlnbp21.h33 /* [RO] 0=OK; 1=over current limit flag */
49 /* [RW] current limit select:
/linux-4.1.27/drivers/power/
H A Dpcf50633-charger.c73 * 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 Dgc.c189 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 Dhugepage-shm.c17 * 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 Dsupply.h116 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 Dsmtdef.c77 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 Dvxfs_lookup.c135 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 Dordered-events.c126 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 Dmmu.c347 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 Dqib_diag.c258 /* 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 Ddma_fifo.c193 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 Dixgbe_lib.c329 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 Ddriver_chipcommon.c152 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 Ddir.c94 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 Dstep_wise.c36 * 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 Dselection.c123 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 Disp1760-if.c34 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 Dmr.c234 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 Dcb710-mmc.c149 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 Drt2x00mmio.c123 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 Dapbps2.c109 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 Dtty_buffer.c25 * 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 Dcpwd.c104 * 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 Dpgalloc.h59 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 Darch.h30 * 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 Dmq_open_tests.c439 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 Dtioce_provider.c696 * @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 Dmain.c93 .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 Diommu.c191 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 Dpmbus_core.c690 * 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 Dsmiapp-quirk.c48 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 Dtda18271-maps.c959 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 Dm5602_ov9650.h258 /* 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 Diwl-debug.h79 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

Completed in 6143 milliseconds

1234567891011