gpio: gpiolib: Support for open source/emitter gpios
[linux-2.6.git] / include / linux / topology.h
1 /*
2  * include/linux/topology.h
3  *
4  * Written by: Matthew Dobson, IBM Corporation
5  *
6  * Copyright (C) 2002, IBM Corp.
7  *
8  * All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
18  * NON INFRINGEMENT.  See the GNU General Public License for more
19  * details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  *
25  * Send feedback to <colpatch@us.ibm.com>
26  */
27 #ifndef _LINUX_TOPOLOGY_H
28 #define _LINUX_TOPOLOGY_H
29
30 #include <linux/cpumask.h>
31 #include <linux/bitops.h>
32 #include <linux/mmzone.h>
33 #include <linux/smp.h>
34 #include <linux/percpu.h>
35 #include <asm/topology.h>
36
37 #ifndef node_has_online_mem
38 #define node_has_online_mem(nid) (1)
39 #endif
40
41 #ifndef nr_cpus_node
42 #define nr_cpus_node(node) cpumask_weight(cpumask_of_node(node))
43 #endif
44
45 #define for_each_node_with_cpus(node)                   \
46         for_each_online_node(node)                      \
47                 if (nr_cpus_node(node))
48
49 int arch_update_cpu_topology(void);
50
51 /* Conform to ACPI 2.0 SLIT distance definitions */
52 #define LOCAL_DISTANCE          10
53 #define REMOTE_DISTANCE         20
54 #ifndef node_distance
55 #define node_distance(from,to)  ((from) == (to) ? LOCAL_DISTANCE : REMOTE_DISTANCE)
56 #endif
57 #ifndef RECLAIM_DISTANCE
58 /*
59  * If the distance between nodes in a system is larger than RECLAIM_DISTANCE
60  * (in whatever arch specific measurement units returned by node_distance())
61  * then switch on zone reclaim on boot.
62  */
63 #define RECLAIM_DISTANCE 30
64 #endif
65 #ifndef PENALTY_FOR_NODE_WITH_CPUS
66 #define PENALTY_FOR_NODE_WITH_CPUS      (1)
67 #endif
68
69 /*
70  * Below are the 3 major initializers used in building sched_domains:
71  * SD_SIBLING_INIT, for SMT domains
72  * SD_CPU_INIT, for SMP domains
73  * SD_NODE_INIT, for NUMA domains
74  *
75  * Any architecture that cares to do any tuning to these values should do so
76  * by defining their own arch-specific initializer in include/asm/topology.h.
77  * A definition there will automagically override these default initializers
78  * and allow arch-specific performance tuning of sched_domains.
79  * (Only non-zero and non-null fields need be specified.)
80  */
81
82 #ifdef CONFIG_SCHED_SMT
83 /* MCD - Do we really need this?  It is always on if CONFIG_SCHED_SMT is,
84  * so can't we drop this in favor of CONFIG_SCHED_SMT?
85  */
86 #define ARCH_HAS_SCHED_WAKE_IDLE
87 /* Common values for SMT siblings */
88 #ifndef SD_SIBLING_INIT
89 #define SD_SIBLING_INIT (struct sched_domain) {                         \
90         .min_interval           = 1,                                    \
91         .max_interval           = 2,                                    \
92         .busy_factor            = 64,                                   \
93         .imbalance_pct          = 110,                                  \
94                                                                         \
95         .flags                  = 1*SD_LOAD_BALANCE                     \
96                                 | 1*SD_BALANCE_NEWIDLE                  \
97                                 | 1*SD_BALANCE_EXEC                     \
98                                 | 1*SD_BALANCE_FORK                     \
99                                 | 0*SD_BALANCE_WAKE                     \
100                                 | 1*SD_WAKE_AFFINE                      \
101                                 | 1*SD_SHARE_CPUPOWER                   \
102                                 | 0*SD_POWERSAVINGS_BALANCE             \
103                                 | 1*SD_SHARE_PKG_RESOURCES              \
104                                 | 0*SD_SERIALIZE                        \
105                                 | 0*SD_PREFER_SIBLING                   \
106                                 | arch_sd_sibling_asym_packing()        \
107                                 ,                                       \
108         .last_balance           = jiffies,                              \
109         .balance_interval       = 1,                                    \
110         .smt_gain               = 1178, /* 15% */                       \
111 }
112 #endif
113 #endif /* CONFIG_SCHED_SMT */
114
115 #ifdef CONFIG_SCHED_MC
116 /* Common values for MC siblings. for now mostly derived from SD_CPU_INIT */
117 #ifndef SD_MC_INIT
118 #define SD_MC_INIT (struct sched_domain) {                              \
119         .min_interval           = 1,                                    \
120         .max_interval           = 4,                                    \
121         .busy_factor            = 64,                                   \
122         .imbalance_pct          = 125,                                  \
123         .cache_nice_tries       = 1,                                    \
124         .busy_idx               = 2,                                    \
125         .wake_idx               = 0,                                    \
126         .forkexec_idx           = 0,                                    \
127                                                                         \
128         .flags                  = 1*SD_LOAD_BALANCE                     \
129                                 | 1*SD_BALANCE_NEWIDLE                  \
130                                 | 1*SD_BALANCE_EXEC                     \
131                                 | 1*SD_BALANCE_FORK                     \
132                                 | 0*SD_BALANCE_WAKE                     \
133                                 | 1*SD_WAKE_AFFINE                      \
134                                 | 0*SD_PREFER_LOCAL                     \
135                                 | 0*SD_SHARE_CPUPOWER                   \
136                                 | 1*SD_SHARE_PKG_RESOURCES              \
137                                 | 0*SD_SERIALIZE                        \
138                                 | sd_balance_for_mc_power()             \
139                                 | sd_power_saving_flags()               \
140                                 ,                                       \
141         .last_balance           = jiffies,                              \
142         .balance_interval       = 1,                                    \
143 }
144 #endif
145 #endif /* CONFIG_SCHED_MC */
146
147 /* Common values for CPUs */
148 #ifndef SD_CPU_INIT
149 #define SD_CPU_INIT (struct sched_domain) {                             \
150         .min_interval           = 1,                                    \
151         .max_interval           = 4,                                    \
152         .busy_factor            = 64,                                   \
153         .imbalance_pct          = 125,                                  \
154         .cache_nice_tries       = 1,                                    \
155         .busy_idx               = 2,                                    \
156         .idle_idx               = 1,                                    \
157         .newidle_idx            = 0,                                    \
158         .wake_idx               = 0,                                    \
159         .forkexec_idx           = 0,                                    \
160                                                                         \
161         .flags                  = 1*SD_LOAD_BALANCE                     \
162                                 | 1*SD_BALANCE_NEWIDLE                  \
163                                 | 1*SD_BALANCE_EXEC                     \
164                                 | 1*SD_BALANCE_FORK                     \
165                                 | 0*SD_BALANCE_WAKE                     \
166                                 | 1*SD_WAKE_AFFINE                      \
167                                 | 0*SD_PREFER_LOCAL                     \
168                                 | 0*SD_SHARE_CPUPOWER                   \
169                                 | 0*SD_SHARE_PKG_RESOURCES              \
170                                 | 0*SD_SERIALIZE                        \
171                                 | sd_balance_for_package_power()        \
172                                 | sd_power_saving_flags()               \
173                                 ,                                       \
174         .last_balance           = jiffies,                              \
175         .balance_interval       = 1,                                    \
176 }
177 #endif
178
179 /* sched_domains SD_ALLNODES_INIT for NUMA machines */
180 #define SD_ALLNODES_INIT (struct sched_domain) {                        \
181         .min_interval           = 64,                                   \
182         .max_interval           = 64*num_online_cpus(),                 \
183         .busy_factor            = 128,                                  \
184         .imbalance_pct          = 133,                                  \
185         .cache_nice_tries       = 1,                                    \
186         .busy_idx               = 3,                                    \
187         .idle_idx               = 3,                                    \
188         .flags                  = 1*SD_LOAD_BALANCE                     \
189                                 | 1*SD_BALANCE_NEWIDLE                  \
190                                 | 0*SD_BALANCE_EXEC                     \
191                                 | 0*SD_BALANCE_FORK                     \
192                                 | 0*SD_BALANCE_WAKE                     \
193                                 | 0*SD_WAKE_AFFINE                      \
194                                 | 0*SD_SHARE_CPUPOWER                   \
195                                 | 0*SD_POWERSAVINGS_BALANCE             \
196                                 | 0*SD_SHARE_PKG_RESOURCES              \
197                                 | 1*SD_SERIALIZE                        \
198                                 | 0*SD_PREFER_SIBLING                   \
199                                 ,                                       \
200         .last_balance           = jiffies,                              \
201         .balance_interval       = 64,                                   \
202 }
203
204 #ifdef CONFIG_SCHED_BOOK
205 #ifndef SD_BOOK_INIT
206 #error Please define an appropriate SD_BOOK_INIT in include/asm/topology.h!!!
207 #endif
208 #endif /* CONFIG_SCHED_BOOK */
209
210 #ifdef CONFIG_NUMA
211 #ifndef SD_NODE_INIT
212 #error Please define an appropriate SD_NODE_INIT in include/asm/topology.h!!!
213 #endif
214
215 #endif /* CONFIG_NUMA */
216
217 #ifdef CONFIG_USE_PERCPU_NUMA_NODE_ID
218 DECLARE_PER_CPU(int, numa_node);
219
220 #ifndef numa_node_id
221 /* Returns the number of the current Node. */
222 static inline int numa_node_id(void)
223 {
224         return __this_cpu_read(numa_node);
225 }
226 #endif
227
228 #ifndef cpu_to_node
229 static inline int cpu_to_node(int cpu)
230 {
231         return per_cpu(numa_node, cpu);
232 }
233 #endif
234
235 #ifndef set_numa_node
236 static inline void set_numa_node(int node)
237 {
238         percpu_write(numa_node, node);
239 }
240 #endif
241
242 #ifndef set_cpu_numa_node
243 static inline void set_cpu_numa_node(int cpu, int node)
244 {
245         per_cpu(numa_node, cpu) = node;
246 }
247 #endif
248
249 #else   /* !CONFIG_USE_PERCPU_NUMA_NODE_ID */
250
251 /* Returns the number of the current Node. */
252 #ifndef numa_node_id
253 static inline int numa_node_id(void)
254 {
255         return cpu_to_node(raw_smp_processor_id());
256 }
257 #endif
258
259 #endif  /* [!]CONFIG_USE_PERCPU_NUMA_NODE_ID */
260
261 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
262
263 /*
264  * N.B., Do NOT reference the '_numa_mem_' per cpu variable directly.
265  * It will not be defined when CONFIG_HAVE_MEMORYLESS_NODES is not defined.
266  * Use the accessor functions set_numa_mem(), numa_mem_id() and cpu_to_mem().
267  */
268 DECLARE_PER_CPU(int, _numa_mem_);
269
270 #ifndef set_numa_mem
271 static inline void set_numa_mem(int node)
272 {
273         percpu_write(_numa_mem_, node);
274 }
275 #endif
276
277 #ifndef numa_mem_id
278 /* Returns the number of the nearest Node with memory */
279 static inline int numa_mem_id(void)
280 {
281         return __this_cpu_read(_numa_mem_);
282 }
283 #endif
284
285 #ifndef cpu_to_mem
286 static inline int cpu_to_mem(int cpu)
287 {
288         return per_cpu(_numa_mem_, cpu);
289 }
290 #endif
291
292 #ifndef set_cpu_numa_mem
293 static inline void set_cpu_numa_mem(int cpu, int node)
294 {
295         per_cpu(_numa_mem_, cpu) = node;
296 }
297 #endif
298
299 #else   /* !CONFIG_HAVE_MEMORYLESS_NODES */
300
301 #ifndef numa_mem_id
302 /* Returns the number of the nearest Node with memory */
303 static inline int numa_mem_id(void)
304 {
305         return numa_node_id();
306 }
307 #endif
308
309 #ifndef cpu_to_mem
310 static inline int cpu_to_mem(int cpu)
311 {
312         return cpu_to_node(cpu);
313 }
314 #endif
315
316 #endif  /* [!]CONFIG_HAVE_MEMORYLESS_NODES */
317
318 #ifndef topology_physical_package_id
319 #define topology_physical_package_id(cpu)       ((void)(cpu), -1)
320 #endif
321 #ifndef topology_core_id
322 #define topology_core_id(cpu)                   ((void)(cpu), 0)
323 #endif
324 #ifndef topology_thread_cpumask
325 #define topology_thread_cpumask(cpu)            cpumask_of(cpu)
326 #endif
327 #ifndef topology_core_cpumask
328 #define topology_core_cpumask(cpu)              cpumask_of(cpu)
329 #endif
330
331 #endif /* _LINUX_TOPOLOGY_H */