sys/ofed/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(var, type, mode)                                   \
  92         module_param_named(var, var, type, mode)
  93
  94 #define module_param_array(var, type, addr_argc, mode)                  \
  95         module_param_named(var, var, type, mode)
  96
  97 #define MODULE_PARM_DESC(name, desc)
  98
  99 static inline int
 100 param_set_byte(const char *val, struct kernel_param *kp)
 101 {
 102
 103         return 0;
 104 }
 105
 106 static inline int
 107 param_get_byte(char *buffer, struct kernel_param *kp)
 108 {
 109
 110         return 0;
 111 }
 112
 113
 114 static inline int
 115 param_set_short(const char *val, struct kernel_param *kp)
 116 {
 117
 118         return 0;
 119 }
 120
 121 static inline int
 122 param_get_short(char *buffer, struct kernel_param *kp)
 123 {
 124
 125         return 0;
 126 }
 127
 128
 129 static inline int
 130 param_set_ushort(const char *val, struct kernel_param *kp)
 131 {
 132
 133         return 0;
 134 }
 135
 136 static inline int
 137 param_get_ushort(char *buffer, struct kernel_param *kp)
 138 {
 139
 140         return 0;
 141 }
 142
 143
 144 static inline int
 145 param_set_int(const char *val, struct kernel_param *kp)
 146 {
 147
 148         return 0;
 149 }
 150
 151 static inline int
 152 param_get_int(char *buffer, struct kernel_param *kp)
 153 {
 154
 155         return 0;
 156 }
 157
 158
 159 static inline int
 160 param_set_uint(const char *val, struct kernel_param *kp)
 161 {
 162
 163         return 0;
 164 }
 165
 166 static inline int
 167 param_get_uint(char *buffer, struct kernel_param *kp)
 168 {
 169
 170         return 0;
 171 }
 172
 173
 174 static inline int
 175 param_set_long(const char *val, struct kernel_param *kp)
 176 {
 177
 178         return 0;
 179 }
 180
 181 static inline int
 182 param_get_long(char *buffer, struct kernel_param *kp)
 183 {
 184
 185         return 0;
 186 }
 187
 188
 189 static inline int
 190 param_set_ulong(const char *val, struct kernel_param *kp)
 191 {
 192
 193         return 0;
 194 }
 195
 196 static inline int
 197 param_get_ulong(char *buffer, struct kernel_param *kp)
 198 {
 199
 200         return 0;
 201 }
 202
 203
 204 static inline int
 205 param_set_charp(const char *val, struct kernel_param *kp)
 206 {
 207
 208         return 0;
 209 }
 210
 211 static inline int
 212 param_get_charp(char *buffer, struct kernel_param *kp)
 213 {
 214
 215         return 0;
 216 }
 217
 218
 219 static inline int
 220 param_set_bool(const char *val, struct kernel_param *kp)
 221 {
 222
 223         return 0;
 224 }
 225
 226 static inline int
 227 param_get_bool(char *buffer, struct kernel_param *kp)
 228 {
 229
 230         return 0;
 231 }
 232
 233 #endif  /* _LINUX_MODULEPARAM_H_ */