git.sur5r.net Git - groeck-nct6775/blob - compat.h

   1 #ifndef __COMPAT_H
   2 #define __COMPAT_H
   3
   4 #include <linux/version.h>
   5
   6 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
   7 #error This driver is for kernel versions 2.6.32 and later
   8 #endif
   9
  10 #if !defined (CONFIG_HWMON_VID) && !defined(CONFIG_HWMON_VID_MODULE)
  11 int vid_from_reg(int val, u8 vrm)
  12 {
  13         return 0;
  14 }
  15
  16 u8 vid_which_vrm(void)
  17 {
  18         return 0;
  19 }
  20 #endif
  21
  22 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
  23 #if !(defined RHEL_MAJOR && RHEL_MAJOR == 6 && RHEL_MINOR >= 7)
  24 static int sysfs_create_groups(struct kobject *kobj,
  25                                const struct attribute_group **groups)
  26 {
  27         int error = 0;
  28         int i;
  29
  30         if (!groups)
  31                 return 0;
  32
  33         for (i = 0; groups[i]; i++) {
  34                 error = sysfs_create_group(kobj, groups[i]);
  35                 if (error) {
  36                         while (--i >= 0)
  37                                 sysfs_remove_group(kobj, groups[i]);
  38                         break;
  39                 }
  40         }
  41         return error;
  42 }
  43 #endif
  44
  45 static void sysfs_remove_groups(struct kobject *kobj,
  46                                 const struct attribute_group **groups)
  47 {
  48         int i;
  49
  50         if (!groups)
  51                 return;
  52         for (i = 0; groups[i]; i++)
  53                 sysfs_remove_group(kobj, groups[i]);
  54 }
  55
  56 #if !(defined RHEL_MAJOR && RHEL_MAJOR == 6 && RHEL_MINOR >= 7)
  57 static inline int __must_check PTR_ERR_OR_ZERO(__force const void *ptr)
  58 {
  59         if (IS_ERR(ptr))
  60                 return PTR_ERR(ptr);
  61         else
  62                 return 0;
  63 }
  64 #endif
  65 #endif
  66
  67 #ifdef __NEED_I2C__
  68
  69 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 21)
  70 #if !(defined RHEL_MAJOR && RHEL_MAJOR == 5 && RHEL_MINOR >= 6)
  71 /* Simplified version for compatibility */
  72 struct i2c_board_info {
  73         char            type[I2C_NAME_SIZE];
  74         unsigned short  flags;
  75         unsigned short  addr;
  76 };
  77 #endif
  78 #endif
  79
  80 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 25)
  81 /* Some older kernels have a different, useless struct i2c_device_id */
  82 #define i2c_device_id i2c_device_id_compat
  83 struct i2c_device_id {
  84         char name[I2C_NAME_SIZE];
  85         kernel_ulong_t driver_data      /* Data private to the driver */
  86                         __attribute__((aligned(sizeof(kernel_ulong_t))));
  87 };
  88 #endif
  89
  90 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 32)
  91 static unsigned short empty_i2c[] =  { I2C_CLIENT_END };
  92 static struct i2c_client_address_data addr_data = {
  93         .normal_i2c     = normal_i2c,
  94         .probe          = empty_i2c,
  95         .ignore         = empty_i2c,
  96 };
  97 #endif
  98
  99 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
 100 static inline s32
 101 i2c_smbus_read_word_swapped(const struct i2c_client *client, u8 command)
 102 {
 103         s32 value = i2c_smbus_read_word_data(client, command);
 104
 105         return (value < 0) ? value : swab16(value);
 106 }
 107
 108 static inline s32
 109 i2c_smbus_write_word_swapped(const struct i2c_client *client,
 110                              u8 command, u16 value)
 111 {
 112         return i2c_smbus_write_word_data(client, command, swab16(value));
 113 }
 114 #endif
 115
 116 /* Red Hat EL5 includes backports of these functions, so we can't redefine
 117  * our own. */
 118 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 24)
 119 #if !(defined RHEL_MAJOR && RHEL_MAJOR == 5 && RHEL_MINOR >= 5)
 120 static inline int strict_strtoul(const char *cp, unsigned int base,
 121                                  unsigned long *res)
 122 {
 123         *res = simple_strtoul(cp, NULL, base);
 124         return 0;
 125 }
 126
 127 static inline int strict_strtol(const char *cp, unsigned int base, long *res)
 128 {
 129         *res = simple_strtol(cp, NULL, base);
 130         return 0;
 131 }
 132 #endif
 133 #endif
 134
 135 #endif  /* __NEED_I2C__ */
 136
 137 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 28)
 138 /*
 139  * Divide positive or negative dividend by positive divisor and round
 140  * to closest integer. Result is undefined for negative divisors and
 141  * for negative dividends if the divisor variable type is unsigned.
 142  */
 143 #define DIV_ROUND_CLOSEST(x, divisor)(                  \
 144 {                                                       \
 145         typeof(x) __x = x;                              \
 146         typeof(divisor) __d = divisor;                  \
 147         (((typeof(x))-1) > 0 ||                         \
 148          ((typeof(divisor))-1) > 0 || (__x) > 0) ?      \
 149                 (((__x) + ((__d) / 2)) / (__d)) :       \
 150                 (((__x) - ((__d) / 2)) / (__d));        \
 151 }                                                       \
 152 )
 153 #endif
 154
 155 #ifndef module_driver
 156 /**
 157  * module_driver() - Helper macro for drivers that don't do anything
 158  * special in module init/exit. This eliminates a lot of boilerplate.
 159  * Each module may only use this macro once, and calling it replaces
 160  * module_init() and module_exit().
 161  *
 162  * @__driver: driver name
 163  * @__register: register function for this driver type
 164  * @__unregister: unregister function for this driver type
 165  * @...: Additional arguments to be passed to __register and __unregister.
 166  *
 167  * Use this macro to construct bus specific macros for registering
 168  * drivers, and do not use it on its own.
 169  */
 170 #define module_driver(__driver, __register, __unregister, ...) \
 171 static int __init __driver##_init(void) \
 172 { \
 173         return __register(&(__driver) , ##__VA_ARGS__); \
 174 } \
 175 module_init(__driver##_init); \
 176 static void __exit __driver##_exit(void) \
 177 { \
 178         __unregister(&(__driver) , ##__VA_ARGS__); \
 179 } \
 180 module_exit(__driver##_exit);
 181 #endif
 182
 183 #ifdef __NEED_I2C__
 184
 185 #ifndef module_i2c_driver
 186 /**
 187  * module_i2c_driver() - Helper macro for registering a I2C driver
 188  * @__i2c_driver: i2c_driver struct
 189  *
 190  * Helper macro for I2C drivers which do not do anything special in module
 191  * init/exit. This eliminates a lot of boilerplate. Each module may only
 192  * use this macro once, and calling it replaces module_init() and module_exit()
 193  */
 194 #define module_i2c_driver(__i2c_driver) \
 195         module_driver(__i2c_driver, i2c_add_driver, \
 196                         i2c_del_driver)
 197 #endif
 198
 199 #endif /* __NEED_I2C__ */
 200
 201 #ifndef clamp_val
 202 #define clamp_val SENSORS_LIMIT
 203 #endif
 204
 205 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 12, 0)
 206 #ifndef kstrtol
 207 #define kstrtol strict_strtol
 208 #endif
 209 #ifndef kstrtoul
 210 #define kstrtoul strict_strtoul
 211 #endif
 212 #endif
 213
 214 #ifndef request_muxed_region
 215 #define request_muxed_region(a, b, c) (true)
 216 #endif
 217 #ifndef release_region
 218 #define release_region(a, b)
 219 #endif
 220
 221 #ifndef pr_warn
 222 /* pr_warn macro not introduced until 2.6.35 */
 223 #define pr_warn pr_warning
 224 #endif
 225 #ifndef pr_warn_ratelimited
 226 #define pr_warn_ratelimited pr_warning_ratelimited
 227 #endif
 228
 229 #endif /* __COMPAT_H */