1 /* 2 * Driver for Linear Technology LTC4245 I2C Multiple Supply Hot Swap Controller 3 * 4 * Copyright (C) 2008 Ira W. Snyder <iws@ovro.caltech.edu> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; version 2 of the License. 9 * 10 * This driver is based on the ds1621 and ina209 drivers. 11 * 12 * Datasheet: 13 * http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1003,C1006,C1140,P19392,D13517 14 */ 15 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/err.h> 20 #include <linux/slab.h> 21 #include <linux/i2c.h> 22 #include <linux/hwmon.h> 23 #include <linux/hwmon-sysfs.h> 24 #include <linux/jiffies.h> 25 #include <linux/i2c/ltc4245.h> 26 27 /* Here are names of the chip's registers (a.k.a. commands) */ 28 enum ltc4245_cmd { 29 LTC4245_STATUS = 0x00, /* readonly */ 30 LTC4245_ALERT = 0x01, 31 LTC4245_CONTROL = 0x02, 32 LTC4245_ON = 0x03, 33 LTC4245_FAULT1 = 0x04, 34 LTC4245_FAULT2 = 0x05, 35 LTC4245_GPIO = 0x06, 36 LTC4245_ADCADR = 0x07, 37 38 LTC4245_12VIN = 0x10, 39 LTC4245_12VSENSE = 0x11, 40 LTC4245_12VOUT = 0x12, 41 LTC4245_5VIN = 0x13, 42 LTC4245_5VSENSE = 0x14, 43 LTC4245_5VOUT = 0x15, 44 LTC4245_3VIN = 0x16, 45 LTC4245_3VSENSE = 0x17, 46 LTC4245_3VOUT = 0x18, 47 LTC4245_VEEIN = 0x19, 48 LTC4245_VEESENSE = 0x1a, 49 LTC4245_VEEOUT = 0x1b, 50 LTC4245_GPIOADC = 0x1c, 51 }; 52 53 struct ltc4245_data { 54 struct i2c_client *client; 55 56 const struct attribute_group *groups[3]; 57 58 struct mutex update_lock; 59 bool valid; 60 unsigned long last_updated; /* in jiffies */ 61 62 /* Control registers */ 63 u8 cregs[0x08]; 64 65 /* Voltage registers */ 66 u8 vregs[0x0d]; 67 68 /* GPIO ADC registers */ 69 bool use_extra_gpios; 70 int gpios[3]; 71 }; 72 73 /* 74 * Update the readings from the GPIO pins. If the driver has been configured to 75 * sample all GPIO's as analog voltages, a round-robin sampling method is used. 76 * Otherwise, only the configured GPIO pin is sampled. 77 * 78 * LOCKING: must hold data->update_lock 79 */ 80 static void ltc4245_update_gpios(struct device *dev) 81 { 82 struct ltc4245_data *data = dev_get_drvdata(dev); 83 struct i2c_client *client = data->client; 84 u8 gpio_curr, gpio_next, gpio_reg; 85 int i; 86 87 /* no extra gpio support, we're basically done */ 88 if (!data->use_extra_gpios) { 89 data->gpios[0] = data->vregs[LTC4245_GPIOADC - 0x10]; 90 return; 91 } 92 93 /* 94 * If the last reading was too long ago, then we mark all old GPIO 95 * readings as stale by setting them to -EAGAIN 96 */ 97 if (time_after(jiffies, data->last_updated + 5 * HZ)) { 98 dev_dbg(&client->dev, "Marking GPIOs invalid\n"); 99 for (i = 0; i < ARRAY_SIZE(data->gpios); i++) 100 data->gpios[i] = -EAGAIN; 101 } 102 103 /* 104 * Get the current GPIO pin 105 * 106 * The datasheet calls these GPIO[1-3], but we'll calculate the zero 107 * based array index instead, and call them GPIO[0-2]. This is much 108 * easier to think about. 109 */ 110 gpio_curr = (data->cregs[LTC4245_GPIO] & 0xc0) >> 6; 111 if (gpio_curr > 0) 112 gpio_curr -= 1; 113 114 /* Read the GPIO voltage from the GPIOADC register */ 115 data->gpios[gpio_curr] = data->vregs[LTC4245_GPIOADC - 0x10]; 116 117 /* Find the next GPIO pin to read */ 118 gpio_next = (gpio_curr + 1) % ARRAY_SIZE(data->gpios); 119 120 /* 121 * Calculate the correct setting for the GPIO register so it will 122 * sample the next GPIO pin 123 */ 124 gpio_reg = (data->cregs[LTC4245_GPIO] & 0x3f) | ((gpio_next + 1) << 6); 125 126 /* Update the GPIO register */ 127 i2c_smbus_write_byte_data(client, LTC4245_GPIO, gpio_reg); 128 129 /* Update saved data */ 130 data->cregs[LTC4245_GPIO] = gpio_reg; 131 } 132 133 static struct ltc4245_data *ltc4245_update_device(struct device *dev) 134 { 135 struct ltc4245_data *data = dev_get_drvdata(dev); 136 struct i2c_client *client = data->client; 137 s32 val; 138 int i; 139 140 mutex_lock(&data->update_lock); 141 142 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { 143 144 dev_dbg(&client->dev, "Starting ltc4245 update\n"); 145 146 /* Read control registers -- 0x00 to 0x07 */ 147 for (i = 0; i < ARRAY_SIZE(data->cregs); i++) { 148 val = i2c_smbus_read_byte_data(client, i); 149 if (unlikely(val < 0)) 150 data->cregs[i] = 0; 151 else 152 data->cregs[i] = val; 153 } 154 155 /* Read voltage registers -- 0x10 to 0x1c */ 156 for (i = 0; i < ARRAY_SIZE(data->vregs); i++) { 157 val = i2c_smbus_read_byte_data(client, i+0x10); 158 if (unlikely(val < 0)) 159 data->vregs[i] = 0; 160 else 161 data->vregs[i] = val; 162 } 163 164 /* Update GPIO readings */ 165 ltc4245_update_gpios(dev); 166 167 data->last_updated = jiffies; 168 data->valid = 1; 169 } 170 171 mutex_unlock(&data->update_lock); 172 173 return data; 174 } 175 176 /* Return the voltage from the given register in millivolts */ 177 static int ltc4245_get_voltage(struct device *dev, u8 reg) 178 { 179 struct ltc4245_data *data = ltc4245_update_device(dev); 180 const u8 regval = data->vregs[reg - 0x10]; 181 u32 voltage = 0; 182 183 switch (reg) { 184 case LTC4245_12VIN: 185 case LTC4245_12VOUT: 186 voltage = regval * 55; 187 break; 188 case LTC4245_5VIN: 189 case LTC4245_5VOUT: 190 voltage = regval * 22; 191 break; 192 case LTC4245_3VIN: 193 case LTC4245_3VOUT: 194 voltage = regval * 15; 195 break; 196 case LTC4245_VEEIN: 197 case LTC4245_VEEOUT: 198 voltage = regval * -55; 199 break; 200 case LTC4245_GPIOADC: 201 voltage = regval * 10; 202 break; 203 default: 204 /* If we get here, the developer messed up */ 205 WARN_ON_ONCE(1); 206 break; 207 } 208 209 return voltage; 210 } 211 212 /* Return the current in the given sense register in milliAmperes */ 213 static unsigned int ltc4245_get_current(struct device *dev, u8 reg) 214 { 215 struct ltc4245_data *data = ltc4245_update_device(dev); 216 const u8 regval = data->vregs[reg - 0x10]; 217 unsigned int voltage; 218 unsigned int curr; 219 220 /* 221 * The strange looking conversions that follow are fixed-point 222 * math, since we cannot do floating point in the kernel. 223 * 224 * Step 1: convert sense register to microVolts 225 * Step 2: convert voltage to milliAmperes 226 * 227 * If you play around with the V=IR equation, you come up with 228 * the following: X uV / Y mOhm == Z mA 229 * 230 * With the resistors that are fractions of a milliOhm, we multiply 231 * the voltage and resistance by 10, to shift the decimal point. 232 * Now we can use the normal division operator again. 233 */ 234 235 switch (reg) { 236 case LTC4245_12VSENSE: 237 voltage = regval * 250; /* voltage in uV */ 238 curr = voltage / 50; /* sense resistor 50 mOhm */ 239 break; 240 case LTC4245_5VSENSE: 241 voltage = regval * 125; /* voltage in uV */ 242 curr = (voltage * 10) / 35; /* sense resistor 3.5 mOhm */ 243 break; 244 case LTC4245_3VSENSE: 245 voltage = regval * 125; /* voltage in uV */ 246 curr = (voltage * 10) / 25; /* sense resistor 2.5 mOhm */ 247 break; 248 case LTC4245_VEESENSE: 249 voltage = regval * 250; /* voltage in uV */ 250 curr = voltage / 100; /* sense resistor 100 mOhm */ 251 break; 252 default: 253 /* If we get here, the developer messed up */ 254 WARN_ON_ONCE(1); 255 curr = 0; 256 break; 257 } 258 259 return curr; 260 } 261 262 static ssize_t ltc4245_show_voltage(struct device *dev, 263 struct device_attribute *da, 264 char *buf) 265 { 266 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 267 const int voltage = ltc4245_get_voltage(dev, attr->index); 268 269 return snprintf(buf, PAGE_SIZE, "%d\n", voltage); 270 } 271 272 static ssize_t ltc4245_show_current(struct device *dev, 273 struct device_attribute *da, 274 char *buf) 275 { 276 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 277 const unsigned int curr = ltc4245_get_current(dev, attr->index); 278 279 return snprintf(buf, PAGE_SIZE, "%u\n", curr); 280 } 281 282 static ssize_t ltc4245_show_power(struct device *dev, 283 struct device_attribute *da, 284 char *buf) 285 { 286 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 287 const unsigned int curr = ltc4245_get_current(dev, attr->index); 288 const int output_voltage = ltc4245_get_voltage(dev, attr->index+1); 289 290 /* current in mA * voltage in mV == power in uW */ 291 const unsigned int power = abs(output_voltage * curr); 292 293 return snprintf(buf, PAGE_SIZE, "%u\n", power); 294 } 295 296 static ssize_t ltc4245_show_alarm(struct device *dev, 297 struct device_attribute *da, 298 char *buf) 299 { 300 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da); 301 struct ltc4245_data *data = ltc4245_update_device(dev); 302 const u8 reg = data->cregs[attr->index]; 303 const u32 mask = attr->nr; 304 305 return snprintf(buf, PAGE_SIZE, "%u\n", (reg & mask) ? 1 : 0); 306 } 307 308 static ssize_t ltc4245_show_gpio(struct device *dev, 309 struct device_attribute *da, 310 char *buf) 311 { 312 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 313 struct ltc4245_data *data = ltc4245_update_device(dev); 314 int val = data->gpios[attr->index]; 315 316 /* handle stale GPIO's */ 317 if (val < 0) 318 return val; 319 320 /* Convert to millivolts and print */ 321 return snprintf(buf, PAGE_SIZE, "%u\n", val * 10); 322 } 323 324 /* Construct a sensor_device_attribute structure for each register */ 325 326 /* Input voltages */ 327 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ltc4245_show_voltage, NULL, 328 LTC4245_12VIN); 329 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ltc4245_show_voltage, NULL, 330 LTC4245_5VIN); 331 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, ltc4245_show_voltage, NULL, 332 LTC4245_3VIN); 333 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, ltc4245_show_voltage, NULL, 334 LTC4245_VEEIN); 335 336 /* Input undervoltage alarms */ 337 static SENSOR_DEVICE_ATTR_2(in1_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 338 1 << 0, LTC4245_FAULT1); 339 static SENSOR_DEVICE_ATTR_2(in2_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 340 1 << 1, LTC4245_FAULT1); 341 static SENSOR_DEVICE_ATTR_2(in3_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 342 1 << 2, LTC4245_FAULT1); 343 static SENSOR_DEVICE_ATTR_2(in4_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 344 1 << 3, LTC4245_FAULT1); 345 346 /* Currents (via sense resistor) */ 347 static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc4245_show_current, NULL, 348 LTC4245_12VSENSE); 349 static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc4245_show_current, NULL, 350 LTC4245_5VSENSE); 351 static SENSOR_DEVICE_ATTR(curr3_input, S_IRUGO, ltc4245_show_current, NULL, 352 LTC4245_3VSENSE); 353 static SENSOR_DEVICE_ATTR(curr4_input, S_IRUGO, ltc4245_show_current, NULL, 354 LTC4245_VEESENSE); 355 356 /* Overcurrent alarms */ 357 static SENSOR_DEVICE_ATTR_2(curr1_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 358 1 << 4, LTC4245_FAULT1); 359 static SENSOR_DEVICE_ATTR_2(curr2_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 360 1 << 5, LTC4245_FAULT1); 361 static SENSOR_DEVICE_ATTR_2(curr3_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 362 1 << 6, LTC4245_FAULT1); 363 static SENSOR_DEVICE_ATTR_2(curr4_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 364 1 << 7, LTC4245_FAULT1); 365 366 /* Output voltages */ 367 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, ltc4245_show_voltage, NULL, 368 LTC4245_12VOUT); 369 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, ltc4245_show_voltage, NULL, 370 LTC4245_5VOUT); 371 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, ltc4245_show_voltage, NULL, 372 LTC4245_3VOUT); 373 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, ltc4245_show_voltage, NULL, 374 LTC4245_VEEOUT); 375 376 /* Power Bad alarms */ 377 static SENSOR_DEVICE_ATTR_2(in5_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 378 1 << 0, LTC4245_FAULT2); 379 static SENSOR_DEVICE_ATTR_2(in6_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 380 1 << 1, LTC4245_FAULT2); 381 static SENSOR_DEVICE_ATTR_2(in7_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 382 1 << 2, LTC4245_FAULT2); 383 static SENSOR_DEVICE_ATTR_2(in8_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL, 384 1 << 3, LTC4245_FAULT2); 385 386 /* GPIO voltages */ 387 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, ltc4245_show_gpio, NULL, 0); 388 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, ltc4245_show_gpio, NULL, 1); 389 static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, ltc4245_show_gpio, NULL, 2); 390 391 /* Power Consumption (virtual) */ 392 static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ltc4245_show_power, NULL, 393 LTC4245_12VSENSE); 394 static SENSOR_DEVICE_ATTR(power2_input, S_IRUGO, ltc4245_show_power, NULL, 395 LTC4245_5VSENSE); 396 static SENSOR_DEVICE_ATTR(power3_input, S_IRUGO, ltc4245_show_power, NULL, 397 LTC4245_3VSENSE); 398 static SENSOR_DEVICE_ATTR(power4_input, S_IRUGO, ltc4245_show_power, NULL, 399 LTC4245_VEESENSE); 400 401 /* 402 * Finally, construct an array of pointers to members of the above objects, 403 * as required for sysfs_create_group() 404 */ 405 static struct attribute *ltc4245_std_attributes[] = { 406 &sensor_dev_attr_in1_input.dev_attr.attr, 407 &sensor_dev_attr_in2_input.dev_attr.attr, 408 &sensor_dev_attr_in3_input.dev_attr.attr, 409 &sensor_dev_attr_in4_input.dev_attr.attr, 410 411 &sensor_dev_attr_in1_min_alarm.dev_attr.attr, 412 &sensor_dev_attr_in2_min_alarm.dev_attr.attr, 413 &sensor_dev_attr_in3_min_alarm.dev_attr.attr, 414 &sensor_dev_attr_in4_min_alarm.dev_attr.attr, 415 416 &sensor_dev_attr_curr1_input.dev_attr.attr, 417 &sensor_dev_attr_curr2_input.dev_attr.attr, 418 &sensor_dev_attr_curr3_input.dev_attr.attr, 419 &sensor_dev_attr_curr4_input.dev_attr.attr, 420 421 &sensor_dev_attr_curr1_max_alarm.dev_attr.attr, 422 &sensor_dev_attr_curr2_max_alarm.dev_attr.attr, 423 &sensor_dev_attr_curr3_max_alarm.dev_attr.attr, 424 &sensor_dev_attr_curr4_max_alarm.dev_attr.attr, 425 426 &sensor_dev_attr_in5_input.dev_attr.attr, 427 &sensor_dev_attr_in6_input.dev_attr.attr, 428 &sensor_dev_attr_in7_input.dev_attr.attr, 429 &sensor_dev_attr_in8_input.dev_attr.attr, 430 431 &sensor_dev_attr_in5_min_alarm.dev_attr.attr, 432 &sensor_dev_attr_in6_min_alarm.dev_attr.attr, 433 &sensor_dev_attr_in7_min_alarm.dev_attr.attr, 434 &sensor_dev_attr_in8_min_alarm.dev_attr.attr, 435 436 &sensor_dev_attr_in9_input.dev_attr.attr, 437 438 &sensor_dev_attr_power1_input.dev_attr.attr, 439 &sensor_dev_attr_power2_input.dev_attr.attr, 440 &sensor_dev_attr_power3_input.dev_attr.attr, 441 &sensor_dev_attr_power4_input.dev_attr.attr, 442 443 NULL, 444 }; 445 446 static struct attribute *ltc4245_gpio_attributes[] = { 447 &sensor_dev_attr_in10_input.dev_attr.attr, 448 &sensor_dev_attr_in11_input.dev_attr.attr, 449 NULL, 450 }; 451 452 static const struct attribute_group ltc4245_std_group = { 453 .attrs = ltc4245_std_attributes, 454 }; 455 456 static const struct attribute_group ltc4245_gpio_group = { 457 .attrs = ltc4245_gpio_attributes, 458 }; 459 460 static void ltc4245_sysfs_add_groups(struct ltc4245_data *data) 461 { 462 /* standard sysfs attributes */ 463 data->groups[0] = <c4245_std_group; 464 465 /* if we're using the extra gpio support, register it's attributes */ 466 if (data->use_extra_gpios) 467 data->groups[1] = <c4245_gpio_group; 468 } 469 470 static bool ltc4245_use_extra_gpios(struct i2c_client *client) 471 { 472 struct ltc4245_platform_data *pdata = dev_get_platdata(&client->dev); 473 #ifdef CONFIG_OF 474 struct device_node *np = client->dev.of_node; 475 #endif 476 477 /* prefer platform data */ 478 if (pdata) 479 return pdata->use_extra_gpios; 480 481 #ifdef CONFIG_OF 482 /* fallback on OF */ 483 if (of_find_property(np, "ltc4245,use-extra-gpios", NULL)) 484 return true; 485 #endif 486 487 return false; 488 } 489 490 static int ltc4245_probe(struct i2c_client *client, 491 const struct i2c_device_id *id) 492 { 493 struct i2c_adapter *adapter = client->adapter; 494 struct ltc4245_data *data; 495 struct device *hwmon_dev; 496 497 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 498 return -ENODEV; 499 500 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 501 if (!data) 502 return -ENOMEM; 503 504 data->client = client; 505 mutex_init(&data->update_lock); 506 data->use_extra_gpios = ltc4245_use_extra_gpios(client); 507 508 /* Initialize the LTC4245 chip */ 509 i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00); 510 i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00); 511 512 /* Add sysfs hooks */ 513 ltc4245_sysfs_add_groups(data); 514 515 hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev, 516 client->name, data, 517 data->groups); 518 return PTR_ERR_OR_ZERO(hwmon_dev); 519 } 520 521 static const struct i2c_device_id ltc4245_id[] = { 522 { "ltc4245", 0 }, 523 { } 524 }; 525 MODULE_DEVICE_TABLE(i2c, ltc4245_id); 526 527 /* This is the driver that will be inserted */ 528 static struct i2c_driver ltc4245_driver = { 529 .driver = { 530 .name = "ltc4245", 531 }, 532 .probe = ltc4245_probe, 533 .id_table = ltc4245_id, 534 }; 535 536 module_i2c_driver(ltc4245_driver); 537 538 MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>"); 539 MODULE_DESCRIPTION("LTC4245 driver"); 540 MODULE_LICENSE("GPL"); 541