1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * emc1403.c - SMSC Thermal Driver 4 * 5 * Copyright (C) 2008 Intel Corp 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 */ 11 12 #include <linux/module.h> 13 #include <linux/init.h> 14 #include <linux/slab.h> 15 #include <linux/i2c.h> 16 #include <linux/hwmon.h> 17 #include <linux/hwmon-sysfs.h> 18 #include <linux/err.h> 19 #include <linux/sysfs.h> 20 #include <linux/mutex.h> 21 #include <linux/regmap.h> 22 #include <linux/util_macros.h> 23 24 #define THERMAL_PID_REG 0xfd 25 #define THERMAL_SMSC_ID_REG 0xfe 26 #define THERMAL_REVISION_REG 0xff 27 28 enum emc1403_chip { emc1402, emc1403, emc1404, emc1428 }; 29 30 struct thermal_data { 31 enum emc1403_chip chip; 32 struct regmap *regmap; 33 struct mutex mutex; 34 }; 35 36 static ssize_t power_state_show(struct device *dev, struct device_attribute *attr, char *buf) 37 { 38 struct thermal_data *data = dev_get_drvdata(dev); 39 unsigned int val; 40 int retval; 41 42 retval = regmap_read(data->regmap, 0x03, &val); 43 if (retval < 0) 44 return retval; 45 return sprintf(buf, "%d\n", !!(val & BIT(6))); 46 } 47 48 static ssize_t power_state_store(struct device *dev, struct device_attribute *attr, 49 const char *buf, size_t count) 50 { 51 struct thermal_data *data = dev_get_drvdata(dev); 52 unsigned long val; 53 int retval; 54 55 if (kstrtoul(buf, 10, &val)) 56 return -EINVAL; 57 58 retval = regmap_update_bits(data->regmap, 0x03, BIT(6), 59 val ? BIT(6) : 0); 60 if (retval < 0) 61 return retval; 62 return count; 63 } 64 65 static DEVICE_ATTR_RW(power_state); 66 67 static struct attribute *emc1403_attrs[] = { 68 &dev_attr_power_state.attr, 69 NULL 70 }; 71 ATTRIBUTE_GROUPS(emc1403); 72 73 static int emc1403_detect(struct i2c_client *client, 74 struct i2c_board_info *info) 75 { 76 int id; 77 /* Check if thermal chip is SMSC and EMC1403 or EMC1423 */ 78 79 id = i2c_smbus_read_byte_data(client, THERMAL_SMSC_ID_REG); 80 if (id != 0x5d) 81 return -ENODEV; 82 83 id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG); 84 switch (id) { 85 case 0x20: 86 strscpy(info->type, "emc1402", I2C_NAME_SIZE); 87 break; 88 case 0x21: 89 strscpy(info->type, "emc1403", I2C_NAME_SIZE); 90 break; 91 case 0x22: 92 strscpy(info->type, "emc1422", I2C_NAME_SIZE); 93 break; 94 case 0x23: 95 strscpy(info->type, "emc1423", I2C_NAME_SIZE); 96 break; 97 case 0x25: 98 strscpy(info->type, "emc1404", I2C_NAME_SIZE); 99 break; 100 case 0x27: 101 strscpy(info->type, "emc1424", I2C_NAME_SIZE); 102 break; 103 case 0x29: 104 strscpy(info->type, "emc1428", I2C_NAME_SIZE); 105 break; 106 case 0x59: 107 strscpy(info->type, "emc1438", I2C_NAME_SIZE); 108 break; 109 case 0x60: 110 strscpy(info->type, "emc1442", I2C_NAME_SIZE); 111 break; 112 default: 113 return -ENODEV; 114 } 115 116 id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG); 117 if (id < 0x01 || id > 0x04) 118 return -ENODEV; 119 120 return 0; 121 } 122 123 static bool emc1403_regmap_is_volatile(struct device *dev, unsigned int reg) 124 { 125 switch (reg) { 126 case 0x00: /* internal diode high byte */ 127 case 0x01: /* external diode 1 high byte */ 128 case 0x02: /* status */ 129 case 0x10: /* external diode 1 low byte */ 130 case 0x1b: /* external diode fault */ 131 case 0x23: /* external diode 2 high byte */ 132 case 0x24: /* external diode 2 low byte */ 133 case 0x29: /* internal diode low byte */ 134 case 0x2a: /* externl diode 3 high byte */ 135 case 0x2b: /* external diode 3 low byte */ 136 case 0x35: /* high limit status */ 137 case 0x36: /* low limit status */ 138 case 0x37: /* therm limit status */ 139 case 0x41: /* external diode 4 high byte */ 140 case 0x42: /* external diode 4 low byte */ 141 case 0x43: /* external diode 5 high byte */ 142 case 0x44: /* external diode 5 low byte */ 143 case 0x45: /* external diode 6 high byte */ 144 case 0x46: /* external diode 6 low byte */ 145 case 0x47: /* external diode 7 high byte */ 146 case 0x48: /* external diode 7 low byte */ 147 return true; 148 default: 149 return false; 150 } 151 } 152 153 static const struct regmap_config emc1403_regmap_config = { 154 .reg_bits = 8, 155 .val_bits = 8, 156 .cache_type = REGCACHE_MAPLE, 157 .volatile_reg = emc1403_regmap_is_volatile, 158 }; 159 160 enum emc1403_reg_map {temp_min, temp_max, temp_crit, temp_input}; 161 162 static u8 ema1403_temp_map[] = { 163 [hwmon_temp_min] = temp_min, 164 [hwmon_temp_max] = temp_max, 165 [hwmon_temp_crit] = temp_crit, 166 [hwmon_temp_input] = temp_input, 167 }; 168 169 static u8 emc1403_temp_regs[][4] = { 170 [0] = { 171 [temp_min] = 0x06, 172 [temp_max] = 0x05, 173 [temp_crit] = 0x20, 174 [temp_input] = 0x00, 175 }, 176 [1] = { 177 [temp_min] = 0x08, 178 [temp_max] = 0x07, 179 [temp_crit] = 0x19, 180 [temp_input] = 0x01, 181 }, 182 [2] = { 183 [temp_min] = 0x16, 184 [temp_max] = 0x15, 185 [temp_crit] = 0x1a, 186 [temp_input] = 0x23, 187 }, 188 [3] = { 189 [temp_min] = 0x2d, 190 [temp_max] = 0x2c, 191 [temp_crit] = 0x30, 192 [temp_input] = 0x2a, 193 }, 194 [4] = { 195 [temp_min] = 0x51, 196 [temp_max] = 0x50, 197 [temp_crit] = 0x64, 198 [temp_input] = 0x41, 199 }, 200 [5] = { 201 [temp_min] = 0x55, 202 [temp_max] = 0x54, 203 [temp_crit] = 0x65, 204 [temp_input] = 0x43 205 }, 206 [6] = { 207 [temp_min] = 0x59, 208 [temp_max] = 0x58, 209 [temp_crit] = 0x66, 210 [temp_input] = 0x45, 211 }, 212 [7] = { 213 [temp_min] = 0x5d, 214 [temp_max] = 0x5c, 215 [temp_crit] = 0x67, 216 [temp_input] = 0x47, 217 }, 218 }; 219 220 static s8 emc1403_temp_regs_low[][4] = { 221 [0] = { 222 [temp_min] = -1, 223 [temp_max] = -1, 224 [temp_crit] = -1, 225 [temp_input] = 0x29, 226 }, 227 [1] = { 228 [temp_min] = 0x14, 229 [temp_max] = 0x13, 230 [temp_crit] = -1, 231 [temp_input] = 0x10, 232 }, 233 [2] = { 234 [temp_min] = 0x18, 235 [temp_max] = 0x17, 236 [temp_crit] = -1, 237 [temp_input] = 0x24, 238 }, 239 [3] = { 240 [temp_min] = 0x2f, 241 [temp_max] = 0x2e, 242 [temp_crit] = -1, 243 [temp_input] = 0x2b, 244 }, 245 [4] = { 246 [temp_min] = 0x53, 247 [temp_max] = 0x52, 248 [temp_crit] = -1, 249 [temp_input] = 0x42, 250 }, 251 [5] = { 252 [temp_min] = 0x57, 253 [temp_max] = 0x56, 254 [temp_crit] = -1, 255 [temp_input] = 0x44, 256 }, 257 [6] = { 258 [temp_min] = 0x5b, 259 [temp_max] = 0x5a, 260 [temp_crit] = -1, 261 [temp_input] = 0x46, 262 }, 263 [7] = { 264 [temp_min] = 0x5f, 265 [temp_max] = 0x5e, 266 [temp_crit] = -1, 267 [temp_input] = 0x48, 268 }, 269 }; 270 271 static int __emc1403_get_temp(struct thermal_data *data, int channel, 272 enum emc1403_reg_map map, long *val) 273 { 274 unsigned int regvalh; 275 unsigned int regvall = 0; 276 int ret; 277 s8 reg; 278 279 ret = regmap_read(data->regmap, emc1403_temp_regs[channel][map], ®valh); 280 if (ret < 0) 281 return ret; 282 283 reg = emc1403_temp_regs_low[channel][map]; 284 if (reg >= 0) { 285 ret = regmap_read(data->regmap, reg, ®vall); 286 if (ret < 0) 287 return ret; 288 } 289 290 if (data->chip == emc1428) 291 *val = sign_extend32((regvalh << 3) | (regvall >> 5), 10) * 125; 292 else 293 *val = ((regvalh << 3) | (regvall >> 5)) * 125; 294 295 return 0; 296 } 297 298 static int emc1403_get_temp(struct thermal_data *data, int channel, 299 enum emc1403_reg_map map, long *val) 300 { 301 int ret; 302 303 mutex_lock(&data->mutex); 304 ret = __emc1403_get_temp(data, channel, map, val); 305 mutex_unlock(&data->mutex); 306 307 return ret; 308 } 309 310 static int emc1403_get_hyst(struct thermal_data *data, int channel, 311 enum emc1403_reg_map map, long *val) 312 { 313 int hyst, ret; 314 long limit; 315 316 mutex_lock(&data->mutex); 317 ret = __emc1403_get_temp(data, channel, map, &limit); 318 if (ret < 0) 319 goto unlock; 320 ret = regmap_read(data->regmap, 0x21, &hyst); 321 if (ret < 0) 322 goto unlock; 323 if (map == temp_min) 324 *val = limit + hyst * 1000; 325 else 326 *val = limit - hyst * 1000; 327 unlock: 328 mutex_unlock(&data->mutex); 329 return ret; 330 } 331 332 static int emc1403_temp_read(struct thermal_data *data, u32 attr, int channel, long *val) 333 { 334 unsigned int regval; 335 int ret; 336 337 switch (attr) { 338 case hwmon_temp_min: 339 case hwmon_temp_max: 340 case hwmon_temp_crit: 341 case hwmon_temp_input: 342 ret = emc1403_get_temp(data, channel, ema1403_temp_map[attr], val); 343 break; 344 case hwmon_temp_min_hyst: 345 ret = emc1403_get_hyst(data, channel, temp_min, val); 346 break; 347 case hwmon_temp_max_hyst: 348 ret = emc1403_get_hyst(data, channel, temp_max, val); 349 break; 350 case hwmon_temp_crit_hyst: 351 ret = emc1403_get_hyst(data, channel, temp_crit, val); 352 break; 353 case hwmon_temp_min_alarm: 354 if (data->chip == emc1402) { 355 ret = regmap_read(data->regmap, 0x02, ®val); 356 if (ret < 0) 357 break; 358 *val = !!(regval & BIT(5 - 2 * channel)); 359 } else { 360 ret = regmap_read(data->regmap, 0x36, ®val); 361 if (ret < 0) 362 break; 363 *val = !!(regval & BIT(channel)); 364 } 365 break; 366 case hwmon_temp_max_alarm: 367 if (data->chip == emc1402) { 368 ret = regmap_read(data->regmap, 0x02, ®val); 369 if (ret < 0) 370 break; 371 *val = !!(regval & BIT(6 - 2 * channel)); 372 } else { 373 ret = regmap_read(data->regmap, 0x35, ®val); 374 if (ret < 0) 375 break; 376 *val = !!(regval & BIT(channel)); 377 } 378 break; 379 case hwmon_temp_crit_alarm: 380 if (data->chip == emc1402) { 381 ret = regmap_read(data->regmap, 0x02, ®val); 382 if (ret < 0) 383 break; 384 *val = !!(regval & BIT(channel)); 385 } else { 386 ret = regmap_read(data->regmap, 0x37, ®val); 387 if (ret < 0) 388 break; 389 *val = !!(regval & BIT(channel)); 390 } 391 break; 392 case hwmon_temp_fault: 393 ret = regmap_read(data->regmap, 0x1b, ®val); 394 if (ret < 0) 395 break; 396 *val = !!(regval & BIT(channel)); 397 break; 398 default: 399 return -EOPNOTSUPP; 400 } 401 return ret; 402 } 403 404 static int emc1403_get_convrate(struct thermal_data *data, long *val) 405 { 406 unsigned int convrate; 407 int ret; 408 409 ret = regmap_read(data->regmap, 0x04, &convrate); 410 if (ret < 0) 411 return ret; 412 if (convrate > 10) 413 convrate = 4; 414 415 *val = 16000 >> convrate; 416 return 0; 417 } 418 419 static int emc1403_chip_read(struct thermal_data *data, u32 attr, long *val) 420 { 421 switch (attr) { 422 case hwmon_chip_update_interval: 423 return emc1403_get_convrate(data, val); 424 default: 425 return -EOPNOTSUPP; 426 } 427 } 428 429 static int emc1403_read(struct device *dev, enum hwmon_sensor_types type, 430 u32 attr, int channel, long *val) 431 { 432 struct thermal_data *data = dev_get_drvdata(dev); 433 434 switch (type) { 435 case hwmon_temp: 436 return emc1403_temp_read(data, attr, channel, val); 437 case hwmon_chip: 438 return emc1403_chip_read(data, attr, val); 439 default: 440 return -EOPNOTSUPP; 441 } 442 } 443 444 static int emc1403_set_hyst(struct thermal_data *data, long val) 445 { 446 int hyst, ret; 447 long limit; 448 449 if (data->chip == emc1428) 450 val = clamp_val(val, -128000, 127000); 451 else 452 val = clamp_val(val, 0, 255000); 453 454 mutex_lock(&data->mutex); 455 ret = __emc1403_get_temp(data, 0, temp_crit, &limit); 456 if (ret < 0) 457 goto unlock; 458 459 hyst = limit - val; 460 if (data->chip == emc1428) 461 hyst = clamp_val(DIV_ROUND_CLOSEST(hyst, 1000), 0, 127); 462 else 463 hyst = clamp_val(DIV_ROUND_CLOSEST(hyst, 1000), 0, 255); 464 ret = regmap_write(data->regmap, 0x21, hyst); 465 unlock: 466 mutex_unlock(&data->mutex); 467 return ret; 468 } 469 470 static int emc1403_set_temp(struct thermal_data *data, int channel, 471 enum emc1403_reg_map map, long val) 472 { 473 unsigned int regval; 474 int ret; 475 u8 regh; 476 s8 regl; 477 478 regh = emc1403_temp_regs[channel][map]; 479 regl = emc1403_temp_regs_low[channel][map]; 480 481 mutex_lock(&data->mutex); 482 if (regl >= 0) { 483 if (data->chip == emc1428) 484 val = clamp_val(val, -128000, 127875); 485 else 486 val = clamp_val(val, 0, 255875); 487 regval = DIV_ROUND_CLOSEST(val, 125); 488 ret = regmap_write(data->regmap, regh, (regval >> 3) & 0xff); 489 if (ret < 0) 490 goto unlock; 491 ret = regmap_write(data->regmap, regl, (regval & 0x07) << 5); 492 } else { 493 if (data->chip == emc1428) 494 val = clamp_val(val, -128000, 127000); 495 else 496 val = clamp_val(val, 0, 255000); 497 regval = DIV_ROUND_CLOSEST(val, 1000); 498 ret = regmap_write(data->regmap, regh, regval); 499 } 500 unlock: 501 mutex_unlock(&data->mutex); 502 return ret; 503 } 504 505 static int emc1403_temp_write(struct thermal_data *data, u32 attr, int channel, long val) 506 { 507 switch (attr) { 508 case hwmon_temp_min: 509 case hwmon_temp_max: 510 case hwmon_temp_crit: 511 return emc1403_set_temp(data, channel, ema1403_temp_map[attr], val); 512 case hwmon_temp_crit_hyst: 513 return emc1403_set_hyst(data, val); 514 default: 515 return -EOPNOTSUPP; 516 } 517 } 518 519 /* Lookup table for temperature conversion times in msec */ 520 static const u16 ina3221_conv_time[] = { 521 16000, 8000, 4000, 2000, 1000, 500, 250, 125, 62, 31, 16 522 }; 523 524 static int emc1403_set_convrate(struct thermal_data *data, unsigned int interval) 525 { 526 int convrate; 527 528 convrate = find_closest_descending(interval, ina3221_conv_time, 529 ARRAY_SIZE(ina3221_conv_time)); 530 return regmap_write(data->regmap, 0x04, convrate); 531 } 532 533 static int emc1403_chip_write(struct thermal_data *data, u32 attr, long val) 534 { 535 switch (attr) { 536 case hwmon_chip_update_interval: 537 return emc1403_set_convrate(data, clamp_val(val, 0, 100000)); 538 default: 539 return -EOPNOTSUPP; 540 } 541 } 542 543 static int emc1403_write(struct device *dev, enum hwmon_sensor_types type, 544 u32 attr, int channel, long val) 545 { 546 struct thermal_data *data = dev_get_drvdata(dev); 547 548 switch (type) { 549 case hwmon_temp: 550 return emc1403_temp_write(data, attr, channel, val); 551 case hwmon_chip: 552 return emc1403_chip_write(data, attr, val); 553 default: 554 return -EOPNOTSUPP; 555 } 556 } 557 558 static umode_t emc1403_temp_is_visible(const void *_data, u32 attr, int channel) 559 { 560 const struct thermal_data *data = _data; 561 562 if (data->chip == emc1402 && channel > 1) 563 return 0; 564 if (data->chip == emc1403 && channel > 2) 565 return 0; 566 if (data->chip != emc1428 && channel > 3) 567 return 0; 568 569 switch (attr) { 570 case hwmon_temp_input: 571 case hwmon_temp_min_alarm: 572 case hwmon_temp_max_alarm: 573 case hwmon_temp_crit_alarm: 574 case hwmon_temp_fault: 575 case hwmon_temp_min_hyst: 576 case hwmon_temp_max_hyst: 577 return 0444; 578 case hwmon_temp_min: 579 case hwmon_temp_max: 580 case hwmon_temp_crit: 581 return 0644; 582 case hwmon_temp_crit_hyst: 583 if (channel == 0) 584 return 0644; 585 return 0444; 586 default: 587 return 0; 588 } 589 } 590 591 static umode_t emc1403_chip_is_visible(const void *_data, u32 attr) 592 { 593 switch (attr) { 594 case hwmon_chip_update_interval: 595 return 0644; 596 default: 597 return 0; 598 } 599 } 600 601 static umode_t emc1403_is_visible(const void *data, enum hwmon_sensor_types type, 602 u32 attr, int channel) 603 { 604 switch (type) { 605 case hwmon_temp: 606 return emc1403_temp_is_visible(data, attr, channel); 607 case hwmon_chip: 608 return emc1403_chip_is_visible(data, attr); 609 default: 610 return 0; 611 } 612 } 613 614 static const struct hwmon_channel_info * const emc1403_info[] = { 615 HWMON_CHANNEL_INFO(chip, HWMON_C_UPDATE_INTERVAL), 616 HWMON_CHANNEL_INFO(temp, 617 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 618 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 619 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 620 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM, 621 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 622 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 623 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 624 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT, 625 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 626 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 627 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 628 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT, 629 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 630 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 631 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 632 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT, 633 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 634 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 635 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 636 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT, 637 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 638 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 639 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 640 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT, 641 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 642 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 643 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 644 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT, 645 HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX | 646 HWMON_T_CRIT | HWMON_T_MIN_HYST | HWMON_T_MAX_HYST | 647 HWMON_T_CRIT_HYST | HWMON_T_MIN_ALARM | 648 HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | HWMON_T_FAULT 649 ), 650 NULL 651 }; 652 653 static const struct hwmon_ops emc1403_hwmon_ops = { 654 .is_visible = emc1403_is_visible, 655 .read = emc1403_read, 656 .write = emc1403_write, 657 }; 658 659 static const struct hwmon_chip_info emc1403_chip_info = { 660 .ops = &emc1403_hwmon_ops, 661 .info = emc1403_info, 662 }; 663 664 /* Last digit of chip name indicates number of channels */ 665 static const struct i2c_device_id emc1403_idtable[] = { 666 { "emc1402", emc1402 }, 667 { "emc1403", emc1403 }, 668 { "emc1404", emc1404 }, 669 { "emc1412", emc1402 }, 670 { "emc1413", emc1403 }, 671 { "emc1414", emc1404 }, 672 { "emc1422", emc1402 }, 673 { "emc1423", emc1403 }, 674 { "emc1424", emc1404 }, 675 { "emc1428", emc1428 }, 676 { "emc1438", emc1428 }, 677 { "emc1442", emc1402 }, 678 { } 679 }; 680 MODULE_DEVICE_TABLE(i2c, emc1403_idtable); 681 682 static int emc1403_probe(struct i2c_client *client) 683 { 684 struct thermal_data *data; 685 struct device *hwmon_dev; 686 const struct i2c_device_id *id = i2c_match_id(emc1403_idtable, client); 687 688 data = devm_kzalloc(&client->dev, sizeof(struct thermal_data), 689 GFP_KERNEL); 690 if (!data) 691 return -ENOMEM; 692 693 data->chip = id->driver_data; 694 data->regmap = devm_regmap_init_i2c(client, &emc1403_regmap_config); 695 if (IS_ERR(data->regmap)) 696 return PTR_ERR(data->regmap); 697 698 mutex_init(&data->mutex); 699 700 hwmon_dev = devm_hwmon_device_register_with_info(&client->dev, 701 client->name, data, 702 &emc1403_chip_info, 703 emc1403_groups); 704 return PTR_ERR_OR_ZERO(hwmon_dev); 705 } 706 707 static const unsigned short emc1403_address_list[] = { 708 0x18, 0x1c, 0x29, 0x3c, 0x4c, 0x4d, 0x5c, I2C_CLIENT_END 709 }; 710 711 static struct i2c_driver sensor_emc1403 = { 712 .class = I2C_CLASS_HWMON, 713 .driver = { 714 .name = "emc1403", 715 }, 716 .detect = emc1403_detect, 717 .probe = emc1403_probe, 718 .id_table = emc1403_idtable, 719 .address_list = emc1403_address_list, 720 }; 721 722 module_i2c_driver(sensor_emc1403); 723 724 MODULE_AUTHOR("Kalhan Trisal <kalhan.trisal@intel.com"); 725 MODULE_DESCRIPTION("emc1403 Thermal Driver"); 726 MODULE_LICENSE("GPL v2"); 727