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