param: add kerneldoc to moduleparam.h

	void *elem;

};

/**

 * module_param - typesafe helper for a module/cmdline parameter

 * @value: the variable to alter, and exposed parameter name.

 * @type: the type of the parameter

 * @perm: visibility in sysfs.

 *

 * @value becomes the module parameter, or (prefixed by KBUILD_MODNAME and a

 * ".") the kernel commandline parameter.  Note that - is changed to _, so

 * the user can use "foo-bar=1" even for variable "foo_bar".

 *

 * @perm is 0 if the the variable is not to appear in sysfs, or 0444

 * for world-readable, 0644 for root-writable, etc.  Note that if it

 * is writable, you may need to use kparam_block_sysfs_write() around

 * accesses (esp. charp, which can be kfreed when it changes).

 *

 * The @type is simply pasted to refer to a param_ops_##type and a

 * param_check_##type: for convenience many standard types are provided but

 * you can create your own by defining those variables.

 *

 * Standard types are:

 *	byte, short, ushort, int, uint, long, ulong

 *	charp: a character pointer

 *	bool: a bool, values 0/1, y/n, Y/N.

 *	invbool: the above, only sense-reversed (N = true).

 */

#define module_param(name, type, perm)				\

	module_param_named(name, name, type, perm)

/**

 * module_param_named - typesafe helper for a renamed module/cmdline parameter

 * @name: a valid C identifier which is the parameter name.

 * @value: the actual lvalue to alter.

 * @type: the type of the parameter

 * @perm: visibility in sysfs.

 *

 * Usually it's a good idea to have variable names and user-exposed names the

 * same, but that's harder if the variable must be non-static or is inside a

 * structure.  This allows exposure under a different name.

 */

#define module_param_named(name, value, type, perm)			   \

	param_check_##type(name, &(value));				   \

	module_param_cb(name, &param_ops_##type, &value, perm);		   \

	__MODULE_PARM_TYPE(name, #type)

/**

 * module_param_cb - general callback for a module/cmdline parameter

 * @name: a valid C identifier which is the parameter name.

 * @ops: the set & get operations for this parameter.

 * @perm: visibility in sysfs.

 *

 * The ops can have NULL set or get functions.

 */

#define module_param_cb(name, ops, arg, perm)				      \

	__module_param_call(MODULE_PARAM_PREFIX,			      \

			    name, ops, arg, __same_type(*(arg), bool), perm)

/* On alpha, ia64 and ppc64 relocations to global data cannot go into

   read-only sections (which is part of respective UNIX ABI on these

   platforms). So 'const' makes no sense and even causes compile failures

#endif

/* This is the fundamental function for registering boot/module

   parameters.  perm sets the visibility in sysfs: 000 means it's

   not there, read bits mean it's readable, write bits mean it's

   writable. */

   parameters. */

#define __module_param_call(prefix, name, ops, arg, isbool, perm)	\

	/* Default value instead of permissions? */			\

	static int __param_perm_check_##name __attribute__((unused)) =	\

	return 0;

}

#define module_param_cb(name, ops, arg, perm)				      \

	__module_param_call(MODULE_PARAM_PREFIX,			      \

			    name, ops, arg, __same_type(*(arg), bool), perm)

/*

 * Helper functions: type is byte, short, ushort, int, uint, long,

 * ulong, charp, bool or invbool, or XXX if you define param_ops_XXX

 * and param_check_XXX.

 */

#define module_param_named(name, value, type, perm)			   \

	param_check_##type(name, &(value));				   \

	module_param_cb(name, &param_ops_##type, &value, perm);		   \

	__MODULE_PARM_TYPE(name, #type)

#define module_param(name, type, perm)				\

	module_param_named(name, name, type, perm)

/**

 * kparam_block_sysfs_write - make sure a parameter isn't written via sysfs.

 * @name: the name of the parameter

 * core_param - define a historical core kernel parameter.

 * @name: the name of the cmdline and sysfs parameter (often the same as var)

 * @var: the variable

 * @type: the type (for param_set_##type and param_get_##type)

 * @type: the type of the parameter

 * @perm: visibility in sysfs

 *

 * core_param is just like module_param(), but cannot be modular and

			    &var, __same_type(var, bool), perm)

#endif /* !MODULE */

/* Actually copy string: maxlen param is usually sizeof(string). */

/**

 * module_param_string - a char array parameter

 * @name: the name of the parameter

 * @string: the string variable

 * @len: the maximum length of the string, incl. terminator

 * @perm: visibility in sysfs.

 *

 * This actually copies the string when it's set (unlike type charp).

 * @len is usually just sizeof(string).

 */

#define module_param_string(name, string, len, perm)			\

	static const struct kparam_string __param_string_##name		\

		= { len, string };					\

extern int param_get_invbool(char *buffer, const struct kernel_param *kp);

#define param_check_invbool(name, p) __param_check(name, p, bool)

/* Comma-separated array: *nump is set to number they actually specified. */

/**

 * module_param_array - a parameter which is an array of some type

 * @name: the name of the array variable

 * @type: the type, as per module_param()

 * @nump: optional pointer filled in with the number written

 * @perm: visibility in sysfs

 *

 * Input and output are as comma-separated values.  Commas inside values

 * don't work properly (eg. an array of charp).

 *

 * ARRAY_SIZE(@name) is used to determine the number of elements in the

 * array, so the definition must be visible.

 */

#define module_param_array(name, type, nump, perm)		\

	module_param_array_named(name, name, type, nump, perm)

/**

 * module_param_array_named - renamed parameter which is an array of some type

 * @name: a valid C identifier which is the parameter name

 * @array: the name of the array variable

 * @type: the type, as per module_param()

 * @nump: optional pointer filled in with the number written

 * @perm: visibility in sysfs

 *

 * This exposes a different name than the actual variable name.  See

 * module_param_named() for why this might be necessary.

 */

#define module_param_array_named(name, array, type, nump, perm)		\

	static const struct kparam_array __param_arr_##name		\

	= { ARRAY_SIZE(array), nump, &param_ops_##type,			\

			    __same_type(array[0], bool), perm);		\

	__MODULE_PARM_TYPE(name, "array of " #type)

#define module_param_array(name, type, nump, perm)		\

	module_param_array_named(name, name, type, nump, perm)

extern struct kernel_param_ops param_array_ops;

extern struct kernel_param_ops param_ops_string;