mfd: twl6025: resolve compilation time warnings
[linux-2.6.git] / include / linux / moduleparam.h
1 #ifndef _LINUX_MODULE_PARAMS_H
2 #define _LINUX_MODULE_PARAMS_H
3 /* (C) Copyright 2001, 2002 Rusty Russell IBM Corporation */
4 #include <linux/init.h>
5 #include <linux/stringify.h>
6 #include <linux/kernel.h>
7
8 /* You can override this manually, but generally this should match the
9    module name. */
10 #ifdef MODULE
11 #define MODULE_PARAM_PREFIX /* empty */
12 #else
13 #define MODULE_PARAM_PREFIX KBUILD_MODNAME "."
14 #endif
15
16 /* Chosen so that structs with an unsigned long line up. */
17 #define MAX_PARAM_PREFIX_LEN (64 - sizeof(unsigned long))
18
19 #define ___module_cat(a,b) __mod_ ## a ## b
20 #define __module_cat(a,b) ___module_cat(a,b)
21 #ifdef MODULE
22 #define __MODULE_INFO(tag, name, info)                                    \
23 static const char __module_cat(name,__LINE__)[]                           \
24   __used __attribute__((section(".modinfo"), unused, aligned(1)))         \
25   = __stringify(tag) "=" info
26 #else  /* !MODULE */
27 /* This struct is here for syntactic coherency, it is not used */
28 #define __MODULE_INFO(tag, name, info)                                    \
29   struct __module_cat(name,__LINE__) {}
30 #endif
31 #define __MODULE_PARM_TYPE(name, _type)                                   \
32   __MODULE_INFO(parmtype, name##type, #name ":" _type)
33
34 struct kernel_param;
35
36 struct kernel_param_ops {
37         /* Returns 0, or -errno.  arg is in kp->arg. */
38         int (*set)(const char *val, const struct kernel_param *kp);
39         /* Returns length written or -errno.  Buffer is 4k (ie. be short!) */
40         int (*get)(char *buffer, const struct kernel_param *kp);
41         /* Optional function to free kp->arg when module unloaded. */
42         void (*free)(void *arg);
43 };
44
45 /* Flag bits for kernel_param.flags */
46 #define KPARAM_ISBOOL           2
47
48 struct kernel_param {
49         const char *name;
50         const struct kernel_param_ops *ops;
51         u16 perm;
52         u16 flags;
53         union {
54                 void *arg;
55                 const struct kparam_string *str;
56                 const struct kparam_array *arr;
57         };
58 };
59
60 /* Special one for strings we want to copy into */
61 struct kparam_string {
62         unsigned int maxlen;
63         char *string;
64 };
65
66 /* Special one for arrays */
67 struct kparam_array
68 {
69         unsigned int max;
70         unsigned int elemsize;
71         unsigned int *num;
72         const struct kernel_param_ops *ops;
73         void *elem;
74 };
75
76 /**
77  * module_param - typesafe helper for a module/cmdline parameter
78  * @value: the variable to alter, and exposed parameter name.
79  * @type: the type of the parameter
80  * @perm: visibility in sysfs.
81  *
82  * @value becomes the module parameter, or (prefixed by KBUILD_MODNAME and a
83  * ".") the kernel commandline parameter.  Note that - is changed to _, so
84  * the user can use "foo-bar=1" even for variable "foo_bar".
85  *
86  * @perm is 0 if the the variable is not to appear in sysfs, or 0444
87  * for world-readable, 0644 for root-writable, etc.  Note that if it
88  * is writable, you may need to use kparam_block_sysfs_write() around
89  * accesses (esp. charp, which can be kfreed when it changes).
90  *
91  * The @type is simply pasted to refer to a param_ops_##type and a
92  * param_check_##type: for convenience many standard types are provided but
93  * you can create your own by defining those variables.
94  *
95  * Standard types are:
96  *      byte, short, ushort, int, uint, long, ulong
97  *      charp: a character pointer
98  *      bool: a bool, values 0/1, y/n, Y/N.
99  *      invbool: the above, only sense-reversed (N = true).
100  */
101 #define module_param(name, type, perm)                          \
102         module_param_named(name, name, type, perm)
103
104 /**
105  * module_param_named - typesafe helper for a renamed module/cmdline parameter
106  * @name: a valid C identifier which is the parameter name.
107  * @value: the actual lvalue to alter.
108  * @type: the type of the parameter
109  * @perm: visibility in sysfs.
110  *
111  * Usually it's a good idea to have variable names and user-exposed names the
112  * same, but that's harder if the variable must be non-static or is inside a
113  * structure.  This allows exposure under a different name.
114  */
115 #define module_param_named(name, value, type, perm)                        \
116         param_check_##type(name, &(value));                                \
117         module_param_cb(name, &param_ops_##type, &value, perm);            \
118         __MODULE_PARM_TYPE(name, #type)
119
120 /**
121  * module_param_cb - general callback for a module/cmdline parameter
122  * @name: a valid C identifier which is the parameter name.
123  * @ops: the set & get operations for this parameter.
124  * @perm: visibility in sysfs.
125  *
126  * The ops can have NULL set or get functions.
127  */
128 #define module_param_cb(name, ops, arg, perm)                                 \
129         __module_param_call(MODULE_PARAM_PREFIX,                              \
130                             name, ops, arg, __same_type((arg), bool *), perm)
131
132 /* On alpha, ia64 and ppc64 relocations to global data cannot go into
133    read-only sections (which is part of respective UNIX ABI on these
134    platforms). So 'const' makes no sense and even causes compile failures
135    with some compilers. */
136 #if defined(CONFIG_ALPHA) || defined(CONFIG_IA64) || defined(CONFIG_PPC64)
137 #define __moduleparam_const
138 #else
139 #define __moduleparam_const const
140 #endif
141
142 /* This is the fundamental function for registering boot/module
143    parameters. */
144 #define __module_param_call(prefix, name, ops, arg, isbool, perm)       \
145         /* Default value instead of permissions? */                     \
146         static int __param_perm_check_##name __attribute__((unused)) =  \
147         BUILD_BUG_ON_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2))  \
148         + BUILD_BUG_ON_ZERO(sizeof(""prefix) > MAX_PARAM_PREFIX_LEN);   \
149         static const char __param_str_##name[] = prefix #name;          \
150         static struct kernel_param __moduleparam_const __param_##name   \
151         __used                                                          \
152     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
153         = { __param_str_##name, ops, perm, isbool ? KPARAM_ISBOOL : 0,  \
154             { arg } }
155
156 /* Obsolete - use module_param_cb() */
157 #define module_param_call(name, set, get, arg, perm)                    \
158         static struct kernel_param_ops __param_ops_##name =             \
159                  { (void *)set, (void *)get };                          \
160         __module_param_call(MODULE_PARAM_PREFIX,                        \
161                             name, &__param_ops_##name, arg,             \
162                             __same_type(arg, bool *),                   \
163                             (perm) + sizeof(__check_old_set_param(set))*0)
164
165 /* We don't get oldget: it's often a new-style param_get_uint, etc. */
166 static inline int
167 __check_old_set_param(int (*oldset)(const char *, struct kernel_param *))
168 {
169         return 0;
170 }
171
172 /**
173  * kparam_block_sysfs_write - make sure a parameter isn't written via sysfs.
174  * @name: the name of the parameter
175  *
176  * There's no point blocking write on a paramter that isn't writable via sysfs!
177  */
178 #define kparam_block_sysfs_write(name)                  \
179         do {                                            \
180                 BUG_ON(!(__param_##name.perm & 0222));  \
181                 __kernel_param_lock();                  \
182         } while (0)
183
184 /**
185  * kparam_unblock_sysfs_write - allows sysfs to write to a parameter again.
186  * @name: the name of the parameter
187  */
188 #define kparam_unblock_sysfs_write(name)                \
189         do {                                            \
190                 BUG_ON(!(__param_##name.perm & 0222));  \
191                 __kernel_param_unlock();                \
192         } while (0)
193
194 /**
195  * kparam_block_sysfs_read - make sure a parameter isn't read via sysfs.
196  * @name: the name of the parameter
197  *
198  * This also blocks sysfs writes.
199  */
200 #define kparam_block_sysfs_read(name)                   \
201         do {                                            \
202                 BUG_ON(!(__param_##name.perm & 0444));  \
203                 __kernel_param_lock();                  \
204         } while (0)
205
206 /**
207  * kparam_unblock_sysfs_read - allows sysfs to read a parameter again.
208  * @name: the name of the parameter
209  */
210 #define kparam_unblock_sysfs_read(name)                 \
211         do {                                            \
212                 BUG_ON(!(__param_##name.perm & 0444));  \
213                 __kernel_param_unlock();                \
214         } while (0)
215
216 #ifdef CONFIG_SYSFS
217 extern void __kernel_param_lock(void);
218 extern void __kernel_param_unlock(void);
219 #else
220 static inline void __kernel_param_lock(void)
221 {
222 }
223 static inline void __kernel_param_unlock(void)
224 {
225 }
226 #endif
227
228 #ifndef MODULE
229 /**
230  * core_param - define a historical core kernel parameter.
231  * @name: the name of the cmdline and sysfs parameter (often the same as var)
232  * @var: the variable
233  * @type: the type of the parameter
234  * @perm: visibility in sysfs
235  *
236  * core_param is just like module_param(), but cannot be modular and
237  * doesn't add a prefix (such as "printk.").  This is for compatibility
238  * with __setup(), and it makes sense as truly core parameters aren't
239  * tied to the particular file they're in.
240  */
241 #define core_param(name, var, type, perm)                               \
242         param_check_##type(name, &(var));                               \
243         __module_param_call("", name, &param_ops_##type,                \
244                             &var, __same_type(var, bool), perm)
245 #endif /* !MODULE */
246
247 /**
248  * module_param_string - a char array parameter
249  * @name: the name of the parameter
250  * @string: the string variable
251  * @len: the maximum length of the string, incl. terminator
252  * @perm: visibility in sysfs.
253  *
254  * This actually copies the string when it's set (unlike type charp).
255  * @len is usually just sizeof(string).
256  */
257 #define module_param_string(name, string, len, perm)                    \
258         static const struct kparam_string __param_string_##name         \
259                 = { len, string };                                      \
260         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
261                             &param_ops_string,                          \
262                             .str = &__param_string_##name, 0, perm);    \
263         __MODULE_PARM_TYPE(name, "string")
264
265 /* Called on module insert or kernel boot */
266 extern int parse_args(const char *name,
267                       char *args,
268                       const struct kernel_param *params,
269                       unsigned num,
270                       int (*unknown)(char *param, char *val));
271
272 /* Called by module remove. */
273 #ifdef CONFIG_SYSFS
274 extern void destroy_params(const struct kernel_param *params, unsigned num);
275 #else
276 static inline void destroy_params(const struct kernel_param *params,
277                                   unsigned num)
278 {
279 }
280 #endif /* !CONFIG_SYSFS */
281
282 /* All the helper functions */
283 /* The macros to do compile-time type checking stolen from Jakub
284    Jelinek, who IIRC came up with this idea for the 2.4 module init code. */
285 #define __param_check(name, p, type) \
286         static inline type *__check_##name(void) { return(p); }
287
288 extern struct kernel_param_ops param_ops_byte;
289 extern int param_set_byte(const char *val, const struct kernel_param *kp);
290 extern int param_get_byte(char *buffer, const struct kernel_param *kp);
291 #define param_check_byte(name, p) __param_check(name, p, unsigned char)
292
293 extern struct kernel_param_ops param_ops_short;
294 extern int param_set_short(const char *val, const struct kernel_param *kp);
295 extern int param_get_short(char *buffer, const struct kernel_param *kp);
296 #define param_check_short(name, p) __param_check(name, p, short)
297
298 extern struct kernel_param_ops param_ops_ushort;
299 extern int param_set_ushort(const char *val, const struct kernel_param *kp);
300 extern int param_get_ushort(char *buffer, const struct kernel_param *kp);
301 #define param_check_ushort(name, p) __param_check(name, p, unsigned short)
302
303 extern struct kernel_param_ops param_ops_int;
304 extern int param_set_int(const char *val, const struct kernel_param *kp);
305 extern int param_get_int(char *buffer, const struct kernel_param *kp);
306 #define param_check_int(name, p) __param_check(name, p, int)
307
308 extern struct kernel_param_ops param_ops_uint;
309 extern int param_set_uint(const char *val, const struct kernel_param *kp);
310 extern int param_get_uint(char *buffer, const struct kernel_param *kp);
311 #define param_check_uint(name, p) __param_check(name, p, unsigned int)
312
313 extern struct kernel_param_ops param_ops_long;
314 extern int param_set_long(const char *val, const struct kernel_param *kp);
315 extern int param_get_long(char *buffer, const struct kernel_param *kp);
316 #define param_check_long(name, p) __param_check(name, p, long)
317
318 extern struct kernel_param_ops param_ops_ulong;
319 extern int param_set_ulong(const char *val, const struct kernel_param *kp);
320 extern int param_get_ulong(char *buffer, const struct kernel_param *kp);
321 #define param_check_ulong(name, p) __param_check(name, p, unsigned long)
322
323 extern struct kernel_param_ops param_ops_charp;
324 extern int param_set_charp(const char *val, const struct kernel_param *kp);
325 extern int param_get_charp(char *buffer, const struct kernel_param *kp);
326 #define param_check_charp(name, p) __param_check(name, p, char *)
327
328 /* For historical reasons "bool" parameters can be (unsigned) "int". */
329 extern struct kernel_param_ops param_ops_bool;
330 extern int param_set_bool(const char *val, const struct kernel_param *kp);
331 extern int param_get_bool(char *buffer, const struct kernel_param *kp);
332 #define param_check_bool(name, p)                                       \
333         static inline void __check_##name(void)                         \
334         {                                                               \
335                 BUILD_BUG_ON(!__same_type((p), bool *) &&               \
336                              !__same_type((p), unsigned int *) &&       \
337                              !__same_type((p), int *));                 \
338         }
339
340 extern struct kernel_param_ops param_ops_invbool;
341 extern int param_set_invbool(const char *val, const struct kernel_param *kp);
342 extern int param_get_invbool(char *buffer, const struct kernel_param *kp);
343 #define param_check_invbool(name, p) __param_check(name, p, bool)
344
345 /**
346  * module_param_array - a parameter which is an array of some type
347  * @name: the name of the array variable
348  * @type: the type, as per module_param()
349  * @nump: optional pointer filled in with the number written
350  * @perm: visibility in sysfs
351  *
352  * Input and output are as comma-separated values.  Commas inside values
353  * don't work properly (eg. an array of charp).
354  *
355  * ARRAY_SIZE(@name) is used to determine the number of elements in the
356  * array, so the definition must be visible.
357  */
358 #define module_param_array(name, type, nump, perm)              \
359         module_param_array_named(name, name, type, nump, perm)
360
361 /**
362  * module_param_array_named - renamed parameter which is an array of some type
363  * @name: a valid C identifier which is the parameter name
364  * @array: the name of the array variable
365  * @type: the type, as per module_param()
366  * @nump: optional pointer filled in with the number written
367  * @perm: visibility in sysfs
368  *
369  * This exposes a different name than the actual variable name.  See
370  * module_param_named() for why this might be necessary.
371  */
372 #define module_param_array_named(name, array, type, nump, perm)         \
373         static const struct kparam_array __param_arr_##name             \
374         = { .max = ARRAY_SIZE(array), .num = nump,                      \
375             .ops = &param_ops_##type,                                   \
376             .elemsize = sizeof(array[0]), .elem = array };              \
377         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
378                             &param_array_ops,                           \
379                             .arr = &__param_arr_##name,                 \
380                             __same_type(array[0], bool), perm);         \
381         __MODULE_PARM_TYPE(name, "array of " #type)
382
383 extern struct kernel_param_ops param_array_ops;
384
385 extern struct kernel_param_ops param_ops_string;
386 extern int param_set_copystring(const char *val, const struct kernel_param *);
387 extern int param_get_string(char *buffer, const struct kernel_param *kp);
388
389 /* for exporting parameters in /sys/parameters */
390
391 struct module;
392
393 #if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES)
394 extern int module_param_sysfs_setup(struct module *mod,
395                                     const struct kernel_param *kparam,
396                                     unsigned int num_params);
397
398 extern void module_param_sysfs_remove(struct module *mod);
399 #else
400 static inline int module_param_sysfs_setup(struct module *mod,
401                              const struct kernel_param *kparam,
402                              unsigned int num_params)
403 {
404         return 0;
405 }
406
407 static inline void module_param_sysfs_remove(struct module *mod)
408 { }
409 #endif
410
411 #endif /* _LINUX_MODULE_PARAMS_H */