sys/dev/drm/include/linux/moduleparam.h

   1 /*-
   2  * Copyright (c) 2010 Isilon Systems, Inc.
   3  * Copyright (c) 2010 iX Systems, Inc.
   4  * Copyright (c) 2010 Panasas, Inc.
   5  * Copyright (c) 2013, 2014 Mellanox Technologies, Ltd.
   6  * Copyright (c) 2017 François Tigeot <ftigeot@wolfpond.org>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice unmodified, this list of conditions, and the following
  14  *    disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef _LINUX_MODULEPARAM_H_
  32 #define _LINUX_MODULEPARAM_H_
  33
  34 #include <linux/init.h>
  35 #include <linux/stringify.h>
  36 #include <linux/kernel.h>
  37
  38 /*
  39  * These are presently not hooked up to anything.  In linux the parameters
  40  * can be set when modules are loaded.  On FreeBSD these could be mapped
  41  * to kenv in the future.
  42  */
  43 struct kernel_param;
  44
  45 typedef int (*param_set_fn)(const char *val, struct kernel_param *kp);
  46 typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp);
  47
  48 struct kernel_param {
  49         const char      *name;
  50         u16             perm;
  51         u16             flags;
  52         param_set_fn    set;
  53         param_get_fn    get;
  54         union {
  55                 void    *arg;
  56                 struct kparam_string    *str;
  57                 struct kparam_array     *arr;
  58         } un;
  59 };
  60
  61 #define KPARAM_ISBOOL   2
  62
  63 struct kparam_string {
  64         unsigned int maxlen;
  65         char *string;
  66 };
  67
  68 struct kparam_array
  69 {
  70         unsigned int    max;
  71         unsigned int    *num;
  72         param_set_fn    set;
  73         param_get_fn    get;
  74         unsigned int    elemsize;
  75         void            *elem;
  76 };
  77
  78 static inline void
  79 param_sysinit(struct kernel_param *param)
  80 {
  81 }
  82
  83 #define module_param_call(name, set, get, arg, perm)                    \
  84         static struct kernel_param __param_##name =                     \
  85             { #name, perm, 0, set, get, { arg } };                      \
  86         SYSINIT(name##_param_sysinit, SI_SUB_DRIVERS, SI_ORDER_FIRST,   \
  87             param_sysinit, &__param_##name);
  88
  89 #define module_param_string(name, string, len, perm)
  90
  91 #define module_param_named(name, var, type, mode)                       \
  92         module_param_call(name, param_set_##type, param_get_##type, &var, mode)
  93
  94 #define module_param_named_unsafe(name, var, type, mode)                \
  95         module_param_call(name, param_set_##type, param_get_##type, &var, mode)
  96
  97 #define module_param(var, type, mode)                                   \
  98         module_param_named(var, var, type, mode)
  99
 100 #define module_param_array(var, type, addr_argc, mode)                  \
 101         module_param_named(var, var, type, mode)
 102
 103 #define module_param_unsafe(name, type, perm)
 104
 105 #define MODULE_PARM_DESC(name, desc)
 106
 107 static inline int
 108 param_set_byte(const char *val, struct kernel_param *kp)
 109 {
 110
 111         return 0;
 112 }
 113
 114 static inline int
 115 param_get_byte(char *buffer, struct kernel_param *kp)
 116 {
 117
 118         return 0;
 119 }
 120
 121
 122 static inline int
 123 param_set_short(const char *val, struct kernel_param *kp)
 124 {
 125
 126         return 0;
 127 }
 128
 129 static inline int
 130 param_get_short(char *buffer, struct kernel_param *kp)
 131 {
 132
 133         return 0;
 134 }
 135
 136
 137 static inline int
 138 param_set_ushort(const char *val, struct kernel_param *kp)
 139 {
 140
 141         return 0;
 142 }
 143
 144 static inline int
 145 param_get_ushort(char *buffer, struct kernel_param *kp)
 146 {
 147
 148         return 0;
 149 }
 150
 151
 152 static inline int
 153 param_set_int(const char *val, struct kernel_param *kp)
 154 {
 155
 156         return 0;
 157 }
 158
 159 static inline int
 160 param_get_int(char *buffer, struct kernel_param *kp)
 161 {
 162
 163         return 0;
 164 }
 165
 166
 167 static inline int
 168 param_set_uint(const char *val, struct kernel_param *kp)
 169 {
 170
 171         return 0;
 172 }
 173
 174 static inline int
 175 param_get_uint(char *buffer, struct kernel_param *kp)
 176 {
 177
 178         return 0;
 179 }
 180
 181
 182 static inline int
 183 param_set_long(const char *val, struct kernel_param *kp)
 184 {
 185
 186         return 0;
 187 }
 188
 189 static inline int
 190 param_get_long(char *buffer, struct kernel_param *kp)
 191 {
 192
 193         return 0;
 194 }
 195
 196
 197 static inline int
 198 param_set_ulong(const char *val, struct kernel_param *kp)
 199 {
 200
 201         return 0;
 202 }
 203
 204 static inline int
 205 param_get_ulong(char *buffer, struct kernel_param *kp)
 206 {
 207
 208         return 0;
 209 }
 210
 211
 212 static inline int
 213 param_set_charp(const char *val, struct kernel_param *kp)
 214 {
 215
 216         return 0;
 217 }
 218
 219 static inline int
 220 param_get_charp(char *buffer, struct kernel_param *kp)
 221 {
 222
 223         return 0;
 224 }
 225
 226
 227 static inline int
 228 param_set_bool(const char *val, struct kernel_param *kp)
 229 {
 230
 231         return 0;
 232 }
 233
 234 static inline int
 235 param_get_bool(char *buffer, struct kernel_param *kp)
 236 {
 237
 238         return 0;
 239 }
 240
 241 #endif  /* _LINUX_MODULEPARAM_H_ */