drivers/hwmon/max127.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Hardware monitoring driver for MAX127.
   4  *
   5  * Copyright (c) 2020 Facebook Inc.
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/hwmon.h>
  10 #include <linux/i2c.h>
  11 #include <linux/init.h>
  12 #include <linux/module.h>
  13
  14 /*
  15  * MAX127 Control Byte. Refer to MAX127 datasheet, Table 1 "Control-Byte
  16  * Format" for details.
  17  */
  18 #define MAX127_CTRL_START       BIT(7)
  19 #define MAX127_CTRL_SEL_SHIFT   4
  20 #define MAX127_CTRL_RNG         BIT(3)
  21 #define MAX127_CTRL_BIP         BIT(2)
  22 #define MAX127_CTRL_PD1         BIT(1)
  23 #define MAX127_CTRL_PD0         BIT(0)
  24
  25 #define MAX127_NUM_CHANNELS     8
  26 #define MAX127_SET_CHANNEL(ch)  (((ch) & 7) << MAX127_CTRL_SEL_SHIFT)
  27
  28 /*
  29  * MAX127 channel input ranges. Refer to MAX127 datasheet, Table 3 "Range
  30  * and Polarity Selection" for details.
  31  */
  32 #define MAX127_FULL_RANGE       10000   /* 10V */
  33 #define MAX127_HALF_RANGE       5000    /* 5V */
  34
  35 /*
  36  * MAX127 returns 2 bytes at read:
  37  *   - the first byte contains data[11:4].
  38  *   - the second byte contains data[3:0] (MSB) and 4 dummy 0s (LSB).
  39  * Refer to MAX127 datasheet, "Read a Conversion (Read Cycle)" section
  40  * for details.
  41  */
  42 #define MAX127_DATA_LEN         2
  43 #define MAX127_DATA_SHIFT       4
  44
  45 #define MAX127_SIGN_BIT         BIT(11)
  46
  47 struct max127_data {
  48         struct mutex lock;
  49         struct i2c_client *client;
  50         u8 ctrl_byte[MAX127_NUM_CHANNELS];
  51 };
  52
  53 static int max127_select_channel(struct i2c_client *client, u8 ctrl_byte)
  54 {
  55         int status;
  56         struct i2c_msg msg = {
  57                 .addr = client->addr,
  58                 .flags = 0,
  59                 .len = sizeof(ctrl_byte),
  60                 .buf = &ctrl_byte,
  61         };
  62
  63         status = i2c_transfer(client->adapter, &msg, 1);
  64         if (status < 0)
  65                 return status;
  66         if (status != 1)
  67                 return -EIO;
  68
  69         return 0;
  70 }
  71
  72 static int max127_read_channel(struct i2c_client *client, long *val)
  73 {
  74         int status;
  75         u8 i2c_data[MAX127_DATA_LEN];
  76         struct i2c_msg msg = {
  77                 .addr = client->addr,
  78                 .flags = I2C_M_RD,
  79                 .len = sizeof(i2c_data),
  80                 .buf = i2c_data,
  81         };
  82
  83         status = i2c_transfer(client->adapter, &msg, 1);
  84         if (status < 0)
  85                 return status;
  86         if (status != 1)
  87                 return -EIO;
  88
  89         *val = (i2c_data[1] >> MAX127_DATA_SHIFT) |
  90                 ((u16)i2c_data[0] << MAX127_DATA_SHIFT);
  91         return 0;
  92 }
  93
  94 static long max127_process_raw(u8 ctrl_byte, long raw)
  95 {
  96         long scale, weight;
  97
  98         /*
  99          * MAX127's data coding is binary in unipolar mode with 1 LSB =
 100          * (Full-Scale/4096) and two’s complement binary in bipolar mode
 101          * with 1 LSB = [(2 x |FS|)/4096].
 102          * Refer to MAX127 datasheet, "Transfer Function" section for
 103          * details.
 104          */
 105         scale = (ctrl_byte & MAX127_CTRL_RNG) ? MAX127_FULL_RANGE :
 106                                                 MAX127_HALF_RANGE;
 107         if (ctrl_byte & MAX127_CTRL_BIP) {
 108                 weight = (raw & MAX127_SIGN_BIT);
 109                 raw &= ~MAX127_SIGN_BIT;
 110                 raw -= weight;
 111                 raw *= 2;
 112         }
 113
 114         return raw * scale / 4096;
 115 }
 116
 117 static int max127_read_input(struct max127_data *data, int channel, long *val)
 118 {
 119         long raw;
 120         int status;
 121         struct i2c_client *client = data->client;
 122         u8 ctrl_byte = data->ctrl_byte[channel];
 123
 124         mutex_lock(&data->lock);
 125
 126         status = max127_select_channel(client, ctrl_byte);
 127         if (status)
 128                 goto exit;
 129
 130         status = max127_read_channel(client, &raw);
 131         if (status)
 132                 goto exit;
 133
 134         *val = max127_process_raw(ctrl_byte, raw);
 135
 136 exit:
 137         mutex_unlock(&data->lock);
 138         return status;
 139 }
 140
 141 static int max127_read_min(struct max127_data *data, int channel, long *val)
 142 {
 143         u8 rng_bip = (data->ctrl_byte[channel] >> 2) & 3;
 144         static const int min_input_map[4] = {
 145                 0,                      /* RNG=0, BIP=0 */
 146                 -MAX127_HALF_RANGE,     /* RNG=0, BIP=1 */
 147                 0,                      /* RNG=1, BIP=0 */
 148                 -MAX127_FULL_RANGE,     /* RNG=1, BIP=1 */
 149         };
 150
 151         *val = min_input_map[rng_bip];
 152         return 0;
 153 }
 154
 155 static int max127_read_max(struct max127_data *data, int channel, long *val)
 156 {
 157         u8 rng_bip = (data->ctrl_byte[channel] >> 2) & 3;
 158         static const int max_input_map[4] = {
 159                 MAX127_HALF_RANGE,      /* RNG=0, BIP=0 */
 160                 MAX127_HALF_RANGE,      /* RNG=0, BIP=1 */
 161                 MAX127_FULL_RANGE,      /* RNG=1, BIP=0 */
 162                 MAX127_FULL_RANGE,      /* RNG=1, BIP=1 */
 163         };
 164
 165         *val = max_input_map[rng_bip];
 166         return 0;
 167 }
 168
 169 static int max127_write_min(struct max127_data *data, int channel, long val)
 170 {
 171         u8 ctrl;
 172
 173         mutex_lock(&data->lock);
 174
 175         ctrl = data->ctrl_byte[channel];
 176         if (val <= -MAX127_FULL_RANGE) {
 177                 ctrl |= (MAX127_CTRL_RNG | MAX127_CTRL_BIP);
 178         } else if (val < 0) {
 179                 ctrl |= MAX127_CTRL_BIP;
 180                 ctrl &= ~MAX127_CTRL_RNG;
 181         } else {
 182                 ctrl &= ~MAX127_CTRL_BIP;
 183         }
 184         data->ctrl_byte[channel] = ctrl;
 185
 186         mutex_unlock(&data->lock);
 187
 188         return 0;
 189 }
 190
 191 static int max127_write_max(struct max127_data *data, int channel, long val)
 192 {
 193         mutex_lock(&data->lock);
 194
 195         if (val >= MAX127_FULL_RANGE)
 196                 data->ctrl_byte[channel] |= MAX127_CTRL_RNG;
 197         else
 198                 data->ctrl_byte[channel] &= ~MAX127_CTRL_RNG;
 199
 200         mutex_unlock(&data->lock);
 201
 202         return 0;
 203 }
 204
 205 static umode_t max127_is_visible(const void *_data,
 206                                  enum hwmon_sensor_types type,
 207                                  u32 attr, int channel)
 208 {
 209         if (type == hwmon_in) {
 210                 switch (attr) {
 211                 case hwmon_in_input:
 212                         return 0444;
 213
 214                 case hwmon_in_min:
 215                 case hwmon_in_max:
 216                         return 0644;
 217
 218                 default:
 219                         break;
 220                 }
 221         }
 222
 223         return 0;
 224 }
 225
 226 static int max127_read(struct device *dev, enum hwmon_sensor_types type,
 227                         u32 attr, int channel, long *val)
 228 {
 229         int status;
 230         struct max127_data *data = dev_get_drvdata(dev);
 231
 232         if (type != hwmon_in)
 233                 return -EOPNOTSUPP;
 234
 235         switch (attr) {
 236         case hwmon_in_input:
 237                 status = max127_read_input(data, channel, val);
 238                 break;
 239
 240         case hwmon_in_min:
 241                 status = max127_read_min(data, channel, val);
 242                 break;
 243
 244         case hwmon_in_max:
 245                 status = max127_read_max(data, channel, val);
 246                 break;
 247
 248         default:
 249                 status = -EOPNOTSUPP;
 250                 break;
 251         }
 252
 253         return status;
 254 }
 255
 256 static int max127_write(struct device *dev, enum hwmon_sensor_types type,
 257                         u32 attr, int channel, long val)
 258 {
 259         int status;
 260         struct max127_data *data = dev_get_drvdata(dev);
 261
 262         if (type != hwmon_in)
 263                 return -EOPNOTSUPP;
 264
 265         switch (attr) {
 266         case hwmon_in_min:
 267                 status = max127_write_min(data, channel, val);
 268                 break;
 269
 270         case hwmon_in_max:
 271                 status = max127_write_max(data, channel, val);
 272                 break;
 273
 274         default:
 275                 status = -EOPNOTSUPP;
 276                 break;
 277         }
 278
 279         return status;
 280 }
 281
 282 static const struct hwmon_ops max127_hwmon_ops = {
 283         .is_visible = max127_is_visible,
 284         .read = max127_read,
 285         .write = max127_write,
 286 };
 287
 288 static const struct hwmon_channel_info *max127_info[] = {
 289         HWMON_CHANNEL_INFO(in,
 290                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
 291                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
 292                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
 293                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
 294                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
 295                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
 296                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX,
 297                            HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX),
 298         NULL,
 299 };
 300
 301 static const struct hwmon_chip_info max127_chip_info = {
 302         .ops = &max127_hwmon_ops,
 303         .info = max127_info,
 304 };
 305
 306 static int max127_probe(struct i2c_client *client,
 307                         const struct i2c_device_id *id)
 308 {
 309         int i;
 310         struct device *hwmon_dev;
 311         struct max127_data *data;
 312         struct device *dev = &client->dev;
 313
 314         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
 315         if (!data)
 316                 return -ENOMEM;
 317
 318         data->client = client;
 319         mutex_init(&data->lock);
 320         for (i = 0; i < ARRAY_SIZE(data->ctrl_byte); i++)
 321                 data->ctrl_byte[i] = (MAX127_CTRL_START |
 322                                       MAX127_SET_CHANNEL(i));
 323
 324         hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
 325                                                          data,
 326                                                          &max127_chip_info,
 327                                                          NULL);
 328
 329         return PTR_ERR_OR_ZERO(hwmon_dev);
 330 }
 331
 332 static const struct i2c_device_id max127_id[] = {
 333         { "max127", 0 },
 334         { }
 335 };
 336 MODULE_DEVICE_TABLE(i2c, max127_id);
 337
 338 static struct i2c_driver max127_driver = {
 339         .class          = I2C_CLASS_HWMON,
 340         .driver = {
 341                 .name   = "max127",
 342         },
 343         .probe          = max127_probe,
 344         .id_table       = max127_id,
 345 };
 346
 347 module_i2c_driver(max127_driver);
 348
 349 MODULE_LICENSE("GPL");
 350 MODULE_AUTHOR("Mike Choi <mikechoi@fb.com>");
 351 MODULE_AUTHOR("Tao Ren <rentao.bupt@gmail.com>");
 352 MODULE_DESCRIPTION("MAX127 Hardware Monitoring driver");