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"); 353