#define ___module_cat(a,b) __mod_ ## a ## b

#define __module_cat(a,b) ___module_cat(a,b)

#define __MODULE_INFO(tag, name, info)                      \

static const char __module_cat(name,__LINE__)[]                  \

  __used                                  \

  __attribute__((section(".modinfo"),unused)) = __stringify(tag) "=" info

#define __MODULE_PARM_TYPE(name, _type)                      \

  __MODULE_INFO(parmtype, name##type, #name ":" _type)

/* 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. */

#define __module_param_call(prefix, name, set, get, arg, perm)        \

    /* Default value instead of permissions? */            \

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

    BUILD_BUG_ON_ZERO((perm) <  || (perm) >  || ((perm) & ))    \

    + BUILD_BUG_ON_ZERO(sizeof(""prefix) > MAX_PARAM_PREFIX_LEN);    \

    static const char __param_str_##name[] = prefix #name;        \

    static struct kernel_param __moduleparam_const __param_##name    \

    __used                                \

    __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \

    = { __param_str_##name, perm, set, get, { arg } }

#define module_param_call(name, set, get, arg, perm)                  \

    __module_param_call(MODULE_PARAM_PREFIX, name, set, get, arg, perm)

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

   ulong, charp, bool or invbool, or XXX if you define param_get_XXX,

   param_set_XXX and param_check_XXX. */

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

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

    module_param_call(name, param_set_##type, param_get_##type, &value, perm); \

    __MODULE_PARM_TYPE(name, #type)

#define module_param(name, type, perm)                \

    module_param_named(name, name, type, perm)

static int tiger=;

module_param(tiger,int,S_IRUGO)

#define module_param(name, type, perm)                \

    module_param_named(name, name, type, perm)

module_param_named(tiger,tiger,int,S_IRUGO)    

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

   ulong, charp, bool or invbool, or XXX if you define param_get_XXX,

   param_set_XXX and param_check_XXX. */

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

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

    module_param_call(name, param_set_##type, param_get_##type, &value, perm); \

    __MODULE_PARM_TYPE(name, #type)

__param_check(tiger, &(tiger), int)

#define __param_check(name, p, type) \

    static inline type *__check_##name(void) { return(p); }

static inline int*__check_tiger(void) { return(&(tiger)); 

#define MODULE_PARAM_PREFIX /* empty */

#define module_param_call(name, set, get, arg, perm)                  \

    __module_param_call(MODULE_PARAM_PREFIX, name, set, get, arg, perm)

__module_param_call(MODULE_PARAM_PREFIX,tiger, param_set_int, param_get_int, &tiger, S_IRUGO)

#define __module_param_call(prefix, name, set, get, arg, perm)        \

    /* Default value instead of permissions? */            \

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

    BUILD_BUG_ON_ZERO((perm) <  || (perm) >  || ((perm) & ))    \

    + BUILD_BUG_ON_ZERO(sizeof(""prefix) > MAX_PARAM_PREFIX_LEN);    \

    static const char __param_str_##name[] = prefix #name;        \

    static struct kernel_param __moduleparam_const __param_##name    \

    __used                                \

    __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \

    = { __param_str_##name, perm, set, get, { arg } }

static int __param_perm_check_tiger __attribute__((unused)) =    BUILD_BUG_ON_ZERO((perm) <  || (perm) >  || ((perm) & )) + BUILD_BUG_ON_ZERO(sizeof(""prefix) > MAX_PARAM_PREFIX_LEN);

static const char __param_str_tiger[] = "tiger";    

static struct kernel_param  __param_tiger      __used    __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *))))

            = { __param_str_tiger, S_IRUGO, param_set_int, param_get_int, {&tiger}  }

#define __MODULE_PARM_TYPE(name, _type)                      \

  __MODULE_INFO(parmtype, name##type, #name ":" _type)

__MODULE_INFO(parmtype, tigertype, "tiger" ":" "int")

#define ___module_cat(a,b) __mod_ ## a ## b

#define __module_cat(a,b) ___module_cat(a,b)

#define __MODULE_INFO(tag, name, info)                      \

static const char __module_cat(name,__LINE__)[]    __used           \
  __attribute__((section(".modinfo"),unused)) = __stringify(tag) "=" info

static const char __mod_tigertype__LINE__[] __attribute__((section(".modinfo"),unused)) = "parmtype=tiger:int"

#define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn)      	\

	int param_set_##name(const char *val, struct kernel_param *kp)	\

	{								\

		tmptype l;						\

		int ret;						\

									\

		if (!val) return -EINVAL;				\

		ret = strtolfn(val, 0, &l);				\

		if (ret == -EINVAL || ((type)l != l))			\

			return -EINVAL;					\

		*((type *)kp->arg) = l;					\

		return 0;						\

	}								\

	int param_get_##name(char *buffer, struct kernel_param *kp)	\

	{								\

		return sprintf(buffer, format, *((type *)kp->arg));	\

	}

int param_set_int(const char *val, struct kernel_param *kp)

{

	long l;

	int ret;						

	if (!val) return -EINVAL;

	ret = strict_strtol(val, 0, &l);

	if (ret == -EINVAL || ((long)l != l))

		return -EINVAL;

	*((long *)kp->arg) = l;

	return 0;

}

int param_get_int(char *buffer, struct kernel_param *kp)

{								\

	return sprintf(buffer, "%i", *((long *)kp->arg));

}