include/linux/i2c-sensor.h

   1 /*
   2     i2c-sensor.h - Part of the i2c package
   3     was originally sensors.h - Part of lm_sensors, Linux kernel modules
   4                                for hardware monitoring
   5     Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #ifndef _LINUX_I2C_SENSOR_H
  23 #define _LINUX_I2C_SENSOR_H
  24
  25 /* A structure containing detect information.
  26    Force variables overrule all other variables; they force a detection on
  27    that place. If a specific chip is given, the module blindly assumes this
  28    chip type is present; if a general force (kind == 0) is given, the module
  29    will still try to figure out what type of chip is present. This is useful
  30    if for some reasons the detect for SMBus or ISA address space filled
  31    fails.
  32    probe: insmod parameter. Initialize this list with I2C_CLIENT_ISA_END values.
  33      A list of pairs. The first value is a bus number (ANY_I2C_ISA_BUS for
  34      the ISA bus, -1 for any I2C bus), the second is the address.
  35    kind: The kind of chip. 0 equals any chip.
  36 */
  37 struct i2c_force_data {
  38         unsigned short *force;
  39         unsigned short kind;
  40 };
  41
  42 /* A structure containing the detect information.
  43    normal_i2c: filled in by the module writer. Terminated by I2C_CLIENT_ISA_END.
  44      A list of I2C addresses which should normally be examined.
  45    normal_isa: filled in by the module writer. Terminated by SENSORS_ISA_END.
  46      A list of ISA addresses which should normally be examined.
  47    probe: insmod parameter. Initialize this list with I2C_CLIENT_ISA_END values.
  48      A list of pairs. The first value is a bus number (ANY_I2C_ISA_BUS for
  49      the ISA bus, -1 for any I2C bus), the second is the address. These
  50      addresses are also probed, as if they were in the 'normal' list.
  51    ignore: insmod parameter. Initialize this list with I2C_CLIENT_ISA_END values.
  52      A list of pairs. The first value is a bus number (ANY_I2C_ISA_BUS for
  53      the ISA bus, -1 for any I2C bus), the second is the I2C address. These
  54      addresses are never probed. This parameter overrules 'normal' and
  55      'probe', but not the 'force' lists.
  56    force_data: insmod parameters. A list, ending with an element of which
  57      the force field is NULL.
  58 */
  59 struct i2c_address_data {
  60         unsigned short *normal_i2c;
  61         unsigned int *normal_isa;
  62         unsigned short *probe;
  63         unsigned short *ignore;
  64         struct i2c_force_data *forces;
  65 };
  66
  67 #define SENSORS_MODULE_PARM_FORCE(name) \
  68   I2C_CLIENT_MODULE_PARM(force_ ## name, \
  69                       "List of adapter,address pairs which are unquestionably" \
  70                       " assumed to contain a `" # name "' chip")
  71
  72
  73 /* This defines several insmod variables, and the addr_data structure */
  74 #define SENSORS_INSMOD \
  75   I2C_CLIENT_MODULE_PARM(probe, \
  76                       "List of adapter,address pairs to scan additionally"); \
  77   I2C_CLIENT_MODULE_PARM(ignore, \
  78                       "List of adapter,address pairs not to scan"); \
  79         static struct i2c_address_data addr_data = {                    \
  80                         .normal_i2c =           normal_i2c,             \
  81                         .normal_isa =           normal_isa,             \
  82                         .probe =                probe,                  \
  83                         .ignore =               ignore,                 \
  84                         .forces =               forces,                 \
  85                 }
  86
  87 /* The following functions create an enum with the chip names as elements.
  88    The first element of the enum is any_chip. These are the only macros
  89    a module will want to use. */
  90
  91 #define SENSORS_INSMOD_0 \
  92   enum chips { any_chip }; \
  93   I2C_CLIENT_MODULE_PARM(force, \
  94                       "List of adapter,address pairs to boldly assume " \
  95                       "to be present"); \
  96   static struct i2c_force_data forces[] = {{force,any_chip},{NULL}}; \
  97   SENSORS_INSMOD
  98
  99 #define SENSORS_INSMOD_1(chip1) \
 100   enum chips { any_chip, chip1 }; \
 101   I2C_CLIENT_MODULE_PARM(force, \
 102                       "List of adapter,address pairs to boldly assume " \
 103                       "to be present"); \
 104   SENSORS_MODULE_PARM_FORCE(chip1); \
 105   static struct i2c_force_data forces[] = {{force,any_chip},\
 106                                                  {force_ ## chip1,chip1}, \
 107                                                  {NULL}}; \
 108   SENSORS_INSMOD
 109
 110 #define SENSORS_INSMOD_2(chip1,chip2) \
 111   enum chips { any_chip, chip1, chip2 }; \
 112   I2C_CLIENT_MODULE_PARM(force, \
 113                       "List of adapter,address pairs to boldly assume " \
 114                       "to be present"); \
 115   SENSORS_MODULE_PARM_FORCE(chip1); \
 116   SENSORS_MODULE_PARM_FORCE(chip2); \
 117   static struct i2c_force_data forces[] = {{force,any_chip}, \
 118                                                  {force_ ## chip1,chip1}, \
 119                                                  {force_ ## chip2,chip2}, \
 120                                                  {NULL}}; \
 121   SENSORS_INSMOD
 122
 123 #define SENSORS_INSMOD_3(chip1,chip2,chip3) \
 124   enum chips { any_chip, chip1, chip2, chip3 }; \
 125   I2C_CLIENT_MODULE_PARM(force, \
 126                       "List of adapter,address pairs to boldly assume " \
 127                       "to be present"); \
 128   SENSORS_MODULE_PARM_FORCE(chip1); \
 129   SENSORS_MODULE_PARM_FORCE(chip2); \
 130   SENSORS_MODULE_PARM_FORCE(chip3); \
 131   static struct i2c_force_data forces[] = {{force,any_chip}, \
 132                                                  {force_ ## chip1,chip1}, \
 133                                                  {force_ ## chip2,chip2}, \
 134                                                  {force_ ## chip3,chip3}, \
 135                                                  {NULL}}; \
 136   SENSORS_INSMOD
 137
 138 #define SENSORS_INSMOD_4(chip1,chip2,chip3,chip4) \
 139   enum chips { any_chip, chip1, chip2, chip3, chip4 }; \
 140   I2C_CLIENT_MODULE_PARM(force, \
 141                       "List of adapter,address pairs to boldly assume " \
 142                       "to be present"); \
 143   SENSORS_MODULE_PARM_FORCE(chip1); \
 144   SENSORS_MODULE_PARM_FORCE(chip2); \
 145   SENSORS_MODULE_PARM_FORCE(chip3); \
 146   SENSORS_MODULE_PARM_FORCE(chip4); \
 147   static struct i2c_force_data forces[] = {{force,any_chip}, \
 148                                                  {force_ ## chip1,chip1}, \
 149                                                  {force_ ## chip2,chip2}, \
 150                                                  {force_ ## chip3,chip3}, \
 151                                                  {force_ ## chip4,chip4}, \
 152                                                  {NULL}}; \
 153   SENSORS_INSMOD
 154
 155 #define SENSORS_INSMOD_5(chip1,chip2,chip3,chip4,chip5) \
 156   enum chips { any_chip, chip1, chip2, chip3, chip4, chip5 }; \
 157   I2C_CLIENT_MODULE_PARM(force, \
 158                       "List of adapter,address pairs to boldly assume " \
 159                       "to be present"); \
 160   SENSORS_MODULE_PARM_FORCE(chip1); \
 161   SENSORS_MODULE_PARM_FORCE(chip2); \
 162   SENSORS_MODULE_PARM_FORCE(chip3); \
 163   SENSORS_MODULE_PARM_FORCE(chip4); \
 164   SENSORS_MODULE_PARM_FORCE(chip5); \
 165   static struct i2c_force_data forces[] = {{force,any_chip}, \
 166                                                  {force_ ## chip1,chip1}, \
 167                                                  {force_ ## chip2,chip2}, \
 168                                                  {force_ ## chip3,chip3}, \
 169                                                  {force_ ## chip4,chip4}, \
 170                                                  {force_ ## chip5,chip5}, \
 171                                                  {NULL}}; \
 172   SENSORS_INSMOD
 173
 174 #define SENSORS_INSMOD_6(chip1,chip2,chip3,chip4,chip5,chip6) \
 175   enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6 }; \
 176   I2C_CLIENT_MODULE_PARM(force, \
 177                       "List of adapter,address pairs to boldly assume " \
 178                       "to be present"); \
 179   SENSORS_MODULE_PARM_FORCE(chip1); \
 180   SENSORS_MODULE_PARM_FORCE(chip2); \
 181   SENSORS_MODULE_PARM_FORCE(chip3); \
 182   SENSORS_MODULE_PARM_FORCE(chip4); \
 183   SENSORS_MODULE_PARM_FORCE(chip5); \
 184   SENSORS_MODULE_PARM_FORCE(chip6); \
 185   static struct i2c_force_data forces[] = {{force,any_chip}, \
 186                                                  {force_ ## chip1,chip1}, \
 187                                                  {force_ ## chip2,chip2}, \
 188                                                  {force_ ## chip3,chip3}, \
 189                                                  {force_ ## chip4,chip4}, \
 190                                                  {force_ ## chip5,chip5}, \
 191                                                  {force_ ## chip6,chip6}, \
 192                                                  {NULL}}; \
 193   SENSORS_INSMOD
 194
 195 #define SENSORS_INSMOD_7(chip1,chip2,chip3,chip4,chip5,chip6,chip7) \
 196   enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6, chip7 }; \
 197   I2C_CLIENT_MODULE_PARM(force, \
 198                       "List of adapter,address pairs to boldly assume " \
 199                       "to be present"); \
 200   SENSORS_MODULE_PARM_FORCE(chip1); \
 201   SENSORS_MODULE_PARM_FORCE(chip2); \
 202   SENSORS_MODULE_PARM_FORCE(chip3); \
 203   SENSORS_MODULE_PARM_FORCE(chip4); \
 204   SENSORS_MODULE_PARM_FORCE(chip5); \
 205   SENSORS_MODULE_PARM_FORCE(chip6); \
 206   SENSORS_MODULE_PARM_FORCE(chip7); \
 207   static struct i2c_force_data forces[] = {{force,any_chip}, \
 208                                                  {force_ ## chip1,chip1}, \
 209                                                  {force_ ## chip2,chip2}, \
 210                                                  {force_ ## chip3,chip3}, \
 211                                                  {force_ ## chip4,chip4}, \
 212                                                  {force_ ## chip5,chip5}, \
 213                                                  {force_ ## chip6,chip6}, \
 214                                                  {force_ ## chip7,chip7}, \
 215                                                  {NULL}}; \
 216   SENSORS_INSMOD
 217
 218 #define SENSORS_INSMOD_8(chip1,chip2,chip3,chip4,chip5,chip6,chip7,chip8) \
 219   enum chips { any_chip, chip1, chip2, chip3, chip4, chip5, chip6, chip7, chip8 }; \
 220   I2C_CLIENT_MODULE_PARM(force, \
 221                       "List of adapter,address pairs to boldly assume " \
 222                       "to be present"); \
 223   SENSORS_MODULE_PARM_FORCE(chip1); \
 224   SENSORS_MODULE_PARM_FORCE(chip2); \
 225   SENSORS_MODULE_PARM_FORCE(chip3); \
 226   SENSORS_MODULE_PARM_FORCE(chip4); \
 227   SENSORS_MODULE_PARM_FORCE(chip5); \
 228   SENSORS_MODULE_PARM_FORCE(chip6); \
 229   SENSORS_MODULE_PARM_FORCE(chip7); \
 230   SENSORS_MODULE_PARM_FORCE(chip8); \
 231   static struct i2c_force_data forces[] = {{force,any_chip}, \
 232                                                  {force_ ## chip1,chip1}, \
 233                                                  {force_ ## chip2,chip2}, \
 234                                                  {force_ ## chip3,chip3}, \
 235                                                  {force_ ## chip4,chip4}, \
 236                                                  {force_ ## chip5,chip5}, \
 237                                                  {force_ ## chip6,chip6}, \
 238                                                  {force_ ## chip7,chip7}, \
 239                                                  {force_ ## chip8,chip8}, \
 240                                                  {NULL}}; \
 241   SENSORS_INSMOD
 242
 243 /* Detect function. It iterates over all possible addresses itself. For
 244    SMBus addresses, it will only call found_proc if some client is connected
 245    to the SMBus (unless a 'force' matched); for ISA detections, this is not
 246    done. */
 247 extern int i2c_detect(struct i2c_adapter *adapter,
 248                       struct i2c_address_data *address_data,
 249                       int (*found_proc) (struct i2c_adapter *, int, int));
 250
 251
 252 /* This macro is used to scale user-input to sensible values in almost all
 253    chip drivers. */
 254 static inline int SENSORS_LIMIT(long value, long low, long high)
 255 {
 256         if (value < low)
 257                 return low;
 258         else if (value > high)
 259                 return high;
 260         else
 261                 return value;
 262 }
 263 #endif                          /* def _LINUX_I2C_SENSOR_H */