1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * max6650.c - Part of lm_sensors, Linux kernel modules for hardware 4 * monitoring. 5 * 6 * (C) 2007 by Hans J. Koch <hjk@hansjkoch.de> 7 * 8 * based on code written by John Morris <john.morris@spirentcom.com> 9 * Copyright (c) 2003 Spirent Communications 10 * and Claus Gindhart <claus.gindhart@kontron.com> 11 * 12 * This module has only been tested with the MAX6650 chip. It should 13 * also work with the MAX6651. It does not distinguish max6650 and max6651 14 * chips. 15 * 16 * The datasheet was last seen at: 17 * 18 * http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf 19 */ 20 21 #include <linux/module.h> 22 #include <linux/init.h> 23 #include <linux/slab.h> 24 #include <linux/jiffies.h> 25 #include <linux/i2c.h> 26 #include <linux/hwmon.h> 27 #include <linux/hwmon-sysfs.h> 28 #include <linux/err.h> 29 #include <linux/of_device.h> 30 #include <linux/thermal.h> 31 32 /* 33 * Insmod parameters 34 */ 35 36 /* fan_voltage: 5=5V fan, 12=12V fan, 0=don't change */ 37 static int fan_voltage; 38 /* prescaler: Possible values are 1, 2, 4, 8, 16 or 0 for don't change */ 39 static int prescaler; 40 /* clock: The clock frequency of the chip (max6651 can be clocked externally) */ 41 static int clock = 254000; 42 43 module_param(fan_voltage, int, 0444); 44 module_param(prescaler, int, 0444); 45 module_param(clock, int, 0444); 46 47 /* 48 * MAX 6650/6651 registers 49 */ 50 51 #define MAX6650_REG_SPEED 0x00 52 #define MAX6650_REG_CONFIG 0x02 53 #define MAX6650_REG_GPIO_DEF 0x04 54 #define MAX6650_REG_DAC 0x06 55 #define MAX6650_REG_ALARM_EN 0x08 56 #define MAX6650_REG_ALARM 0x0A 57 #define MAX6650_REG_TACH0 0x0C 58 #define MAX6650_REG_TACH1 0x0E 59 #define MAX6650_REG_TACH2 0x10 60 #define MAX6650_REG_TACH3 0x12 61 #define MAX6650_REG_GPIO_STAT 0x14 62 #define MAX6650_REG_COUNT 0x16 63 64 /* 65 * Config register bits 66 */ 67 68 #define MAX6650_CFG_V12 0x08 69 #define MAX6650_CFG_PRESCALER_MASK 0x07 70 #define MAX6650_CFG_PRESCALER_2 0x01 71 #define MAX6650_CFG_PRESCALER_4 0x02 72 #define MAX6650_CFG_PRESCALER_8 0x03 73 #define MAX6650_CFG_PRESCALER_16 0x04 74 #define MAX6650_CFG_MODE_MASK 0x30 75 #define MAX6650_CFG_MODE_ON 0x00 76 #define MAX6650_CFG_MODE_OFF 0x10 77 #define MAX6650_CFG_MODE_CLOSED_LOOP 0x20 78 #define MAX6650_CFG_MODE_OPEN_LOOP 0x30 79 #define MAX6650_COUNT_MASK 0x03 80 81 /* 82 * Alarm status register bits 83 */ 84 85 #define MAX6650_ALRM_MAX 0x01 86 #define MAX6650_ALRM_MIN 0x02 87 #define MAX6650_ALRM_TACH 0x04 88 #define MAX6650_ALRM_GPIO1 0x08 89 #define MAX6650_ALRM_GPIO2 0x10 90 91 /* Minimum and maximum values of the FAN-RPM */ 92 #define FAN_RPM_MIN 240 93 #define FAN_RPM_MAX 30000 94 95 #define DIV_FROM_REG(reg) (1 << ((reg) & 7)) 96 #define DAC_LIMIT(v12) ((v12) ? 180 : 76) 97 98 /* 99 * Client data (each client gets its own) 100 */ 101 102 struct max6650_data { 103 struct i2c_client *client; 104 struct mutex update_lock; /* protect alarm register updates */ 105 int nr_fans; 106 bool valid; /* false until following fields are valid */ 107 unsigned long last_updated; /* in jiffies */ 108 109 /* register values */ 110 u8 speed; 111 u8 config; 112 u8 tach[4]; 113 u8 count; 114 u8 dac; 115 u8 alarm; 116 u8 alarm_en; 117 unsigned long cooling_dev_state; 118 }; 119 120 static const u8 tach_reg[] = { 121 MAX6650_REG_TACH0, 122 MAX6650_REG_TACH1, 123 MAX6650_REG_TACH2, 124 MAX6650_REG_TACH3, 125 }; 126 127 static const struct of_device_id __maybe_unused max6650_dt_match[] = { 128 { 129 .compatible = "maxim,max6650", 130 .data = (void *)1 131 }, 132 { 133 .compatible = "maxim,max6651", 134 .data = (void *)4 135 }, 136 { }, 137 }; 138 MODULE_DEVICE_TABLE(of, max6650_dt_match); 139 140 static int dac_to_pwm(int dac, bool v12) 141 { 142 /* 143 * Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans. 144 * Lower DAC values mean higher speeds. 145 */ 146 return clamp_val(255 - (255 * dac) / DAC_LIMIT(v12), 0, 255); 147 } 148 149 static u8 pwm_to_dac(unsigned int pwm, bool v12) 150 { 151 int limit = DAC_LIMIT(v12); 152 153 return limit - (limit * pwm) / 255; 154 } 155 156 static struct max6650_data *max6650_update_device(struct device *dev) 157 { 158 struct max6650_data *data = dev_get_drvdata(dev); 159 struct i2c_client *client = data->client; 160 int reg, err = 0; 161 int i; 162 163 mutex_lock(&data->update_lock); 164 165 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { 166 for (i = 0; i < data->nr_fans; i++) { 167 reg = i2c_smbus_read_byte_data(client, tach_reg[i]); 168 if (reg < 0) { 169 err = reg; 170 goto error; 171 } 172 data->tach[i] = reg; 173 } 174 175 /* 176 * Alarms are cleared on read in case the condition that 177 * caused the alarm is removed. Keep the value latched here 178 * for providing the register through different alarm files. 179 */ 180 reg = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM); 181 if (reg < 0) { 182 err = reg; 183 goto error; 184 } 185 data->alarm |= reg; 186 data->last_updated = jiffies; 187 data->valid = true; 188 } 189 190 error: 191 mutex_unlock(&data->update_lock); 192 if (err) 193 data = ERR_PTR(err); 194 return data; 195 } 196 197 /* 198 * Change the operating mode of the chip (if needed). 199 * mode is one of the MAX6650_CFG_MODE_* values. 200 */ 201 static int max6650_set_operating_mode(struct max6650_data *data, u8 mode) 202 { 203 int result; 204 u8 config = data->config; 205 206 if (mode == (config & MAX6650_CFG_MODE_MASK)) 207 return 0; 208 209 config = (config & ~MAX6650_CFG_MODE_MASK) | mode; 210 211 result = i2c_smbus_write_byte_data(data->client, MAX6650_REG_CONFIG, 212 config); 213 if (result < 0) 214 return result; 215 216 data->config = config; 217 218 return 0; 219 } 220 221 /* 222 * Set the fan speed to the specified RPM (or read back the RPM setting). 223 * This works in closed loop mode only. Use pwm1 for open loop speed setting. 224 * 225 * The MAX6650/1 will automatically control fan speed when in closed loop 226 * mode. 227 * 228 * Assumptions: 229 * 230 * 1) The MAX6650/1 internal 254kHz clock frequency is set correctly. Use 231 * the clock module parameter if you need to fine tune this. 232 * 233 * 2) The prescaler (low three bits of the config register) has already 234 * been set to an appropriate value. Use the prescaler module parameter 235 * if your BIOS doesn't initialize the chip properly. 236 * 237 * The relevant equations are given on pages 21 and 22 of the datasheet. 238 * 239 * From the datasheet, the relevant equation when in regulation is: 240 * 241 * [fCLK / (128 x (KTACH + 1))] = 2 x FanSpeed / KSCALE 242 * 243 * where: 244 * 245 * fCLK is the oscillator frequency (either the 254kHz internal 246 * oscillator or the externally applied clock) 247 * 248 * KTACH is the value in the speed register 249 * 250 * FanSpeed is the speed of the fan in rps 251 * 252 * KSCALE is the prescaler value (1, 2, 4, 8, or 16) 253 * 254 * When reading, we need to solve for FanSpeed. When writing, we need to 255 * solve for KTACH. 256 * 257 * Note: this tachometer is completely separate from the tachometers 258 * used to measure the fan speeds. Only one fan's speed (fan1) is 259 * controlled. 260 */ 261 262 static int max6650_set_target(struct max6650_data *data, unsigned long rpm) 263 { 264 int kscale, ktach; 265 266 if (rpm == 0) 267 return max6650_set_operating_mode(data, MAX6650_CFG_MODE_OFF); 268 269 rpm = clamp_val(rpm, FAN_RPM_MIN, FAN_RPM_MAX); 270 271 /* 272 * Divide the required speed by 60 to get from rpm to rps, then 273 * use the datasheet equation: 274 * 275 * KTACH = [(fCLK x KSCALE) / (256 x FanSpeed)] - 1 276 */ 277 278 kscale = DIV_FROM_REG(data->config); 279 ktach = ((clock * kscale) / (256 * rpm / 60)) - 1; 280 if (ktach < 0) 281 ktach = 0; 282 if (ktach > 255) 283 ktach = 255; 284 data->speed = ktach; 285 286 return i2c_smbus_write_byte_data(data->client, MAX6650_REG_SPEED, 287 data->speed); 288 } 289 290 /* 291 * Get gpio alarm status: 292 * Possible values: 293 * 0 = no alarm 294 * 1 = alarm 295 */ 296 297 static ssize_t alarm_show(struct device *dev, 298 struct device_attribute *devattr, char *buf) 299 { 300 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 301 struct max6650_data *data = max6650_update_device(dev); 302 bool alarm; 303 304 if (IS_ERR(data)) 305 return PTR_ERR(data); 306 307 alarm = data->alarm & attr->index; 308 if (alarm) { 309 mutex_lock(&data->update_lock); 310 data->alarm &= ~attr->index; 311 data->valid = false; 312 mutex_unlock(&data->update_lock); 313 } 314 315 return sprintf(buf, "%d\n", alarm); 316 } 317 318 static SENSOR_DEVICE_ATTR_RO(gpio1_alarm, alarm, MAX6650_ALRM_GPIO1); 319 static SENSOR_DEVICE_ATTR_RO(gpio2_alarm, alarm, MAX6650_ALRM_GPIO2); 320 321 static umode_t max6650_attrs_visible(struct kobject *kobj, struct attribute *a, 322 int n) 323 { 324 struct device *dev = kobj_to_dev(kobj); 325 struct max6650_data *data = dev_get_drvdata(dev); 326 struct device_attribute *devattr; 327 328 /* 329 * Hide the alarms that have not been enabled by the firmware 330 */ 331 332 devattr = container_of(a, struct device_attribute, attr); 333 if (devattr == &sensor_dev_attr_gpio1_alarm.dev_attr || 334 devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) { 335 if (!(data->alarm_en & to_sensor_dev_attr(devattr)->index)) 336 return 0; 337 } 338 339 return a->mode; 340 } 341 342 static struct attribute *max6650_attrs[] = { 343 &sensor_dev_attr_gpio1_alarm.dev_attr.attr, 344 &sensor_dev_attr_gpio2_alarm.dev_attr.attr, 345 NULL 346 }; 347 348 static const struct attribute_group max6650_group = { 349 .attrs = max6650_attrs, 350 .is_visible = max6650_attrs_visible, 351 }; 352 353 static const struct attribute_group *max6650_groups[] = { 354 &max6650_group, 355 NULL 356 }; 357 358 static int max6650_init_client(struct max6650_data *data, 359 struct i2c_client *client) 360 { 361 struct device *dev = &client->dev; 362 int reg; 363 int err; 364 u32 voltage; 365 u32 prescale; 366 u32 target_rpm; 367 368 if (of_property_read_u32(dev->of_node, "maxim,fan-microvolt", 369 &voltage)) 370 voltage = fan_voltage; 371 else 372 voltage /= 1000000; /* Microvolts to volts */ 373 if (of_property_read_u32(dev->of_node, "maxim,fan-prescale", 374 &prescale)) 375 prescale = prescaler; 376 377 reg = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG); 378 if (reg < 0) { 379 dev_err(dev, "Error reading config register, aborting.\n"); 380 return reg; 381 } 382 383 switch (voltage) { 384 case 0: 385 break; 386 case 5: 387 reg &= ~MAX6650_CFG_V12; 388 break; 389 case 12: 390 reg |= MAX6650_CFG_V12; 391 break; 392 default: 393 dev_err(dev, "illegal value for fan_voltage (%d)\n", voltage); 394 } 395 396 switch (prescale) { 397 case 0: 398 break; 399 case 1: 400 reg &= ~MAX6650_CFG_PRESCALER_MASK; 401 break; 402 case 2: 403 reg = (reg & ~MAX6650_CFG_PRESCALER_MASK) 404 | MAX6650_CFG_PRESCALER_2; 405 break; 406 case 4: 407 reg = (reg & ~MAX6650_CFG_PRESCALER_MASK) 408 | MAX6650_CFG_PRESCALER_4; 409 break; 410 case 8: 411 reg = (reg & ~MAX6650_CFG_PRESCALER_MASK) 412 | MAX6650_CFG_PRESCALER_8; 413 break; 414 case 16: 415 reg = (reg & ~MAX6650_CFG_PRESCALER_MASK) 416 | MAX6650_CFG_PRESCALER_16; 417 break; 418 default: 419 dev_err(dev, "illegal value for prescaler (%d)\n", prescale); 420 } 421 422 dev_info(dev, "Fan voltage: %dV, prescaler: %d.\n", 423 (reg & MAX6650_CFG_V12) ? 12 : 5, 424 1 << (reg & MAX6650_CFG_PRESCALER_MASK)); 425 426 err = i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, reg); 427 if (err) { 428 dev_err(dev, "Config write error, aborting.\n"); 429 return err; 430 } 431 data->config = reg; 432 433 reg = i2c_smbus_read_byte_data(client, MAX6650_REG_SPEED); 434 if (reg < 0) { 435 dev_err(dev, "Failed to read speed register, aborting.\n"); 436 return reg; 437 } 438 data->speed = reg; 439 440 reg = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC); 441 if (reg < 0) { 442 dev_err(dev, "Failed to read DAC register, aborting.\n"); 443 return reg; 444 } 445 data->dac = reg; 446 447 reg = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT); 448 if (reg < 0) { 449 dev_err(dev, "Failed to read count register, aborting.\n"); 450 return reg; 451 } 452 data->count = reg; 453 454 reg = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN); 455 if (reg < 0) { 456 dev_err(dev, "Failed to read alarm configuration, aborting.\n"); 457 return reg; 458 } 459 data->alarm_en = reg; 460 461 if (!of_property_read_u32(client->dev.of_node, "maxim,fan-target-rpm", 462 &target_rpm)) { 463 max6650_set_target(data, target_rpm); 464 max6650_set_operating_mode(data, MAX6650_CFG_MODE_CLOSED_LOOP); 465 } 466 467 return 0; 468 } 469 470 static int max6650_get_max_state(struct thermal_cooling_device *cdev, 471 unsigned long *state) 472 { 473 *state = 255; 474 475 return 0; 476 } 477 478 static int max6650_get_cur_state(struct thermal_cooling_device *cdev, 479 unsigned long *state) 480 { 481 struct max6650_data *data = cdev->devdata; 482 483 *state = data->cooling_dev_state; 484 485 return 0; 486 } 487 488 static int max6650_set_cur_state(struct thermal_cooling_device *cdev, 489 unsigned long state) 490 { 491 struct max6650_data *data = cdev->devdata; 492 struct i2c_client *client = data->client; 493 int err; 494 495 state = clamp_val(state, 0, 255); 496 497 mutex_lock(&data->update_lock); 498 499 data->dac = pwm_to_dac(state, data->config & MAX6650_CFG_V12); 500 err = i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac); 501 if (!err) { 502 max6650_set_operating_mode(data, state ? 503 MAX6650_CFG_MODE_OPEN_LOOP : 504 MAX6650_CFG_MODE_OFF); 505 data->cooling_dev_state = state; 506 } 507 508 mutex_unlock(&data->update_lock); 509 510 return err; 511 } 512 513 static const struct thermal_cooling_device_ops max6650_cooling_ops = { 514 .get_max_state = max6650_get_max_state, 515 .get_cur_state = max6650_get_cur_state, 516 .set_cur_state = max6650_set_cur_state, 517 }; 518 519 static int max6650_read(struct device *dev, enum hwmon_sensor_types type, 520 u32 attr, int channel, long *val) 521 { 522 struct max6650_data *data = max6650_update_device(dev); 523 int mode; 524 525 if (IS_ERR(data)) 526 return PTR_ERR(data); 527 528 switch (type) { 529 case hwmon_pwm: 530 switch (attr) { 531 case hwmon_pwm_input: 532 *val = dac_to_pwm(data->dac, 533 data->config & MAX6650_CFG_V12); 534 break; 535 case hwmon_pwm_enable: 536 /* 537 * Possible values: 538 * 0 = Fan always on 539 * 1 = Open loop, Voltage is set according to speed, 540 * not regulated. 541 * 2 = Closed loop, RPM for all fans regulated by fan1 542 * tachometer 543 * 3 = Fan off 544 */ 545 mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4; 546 *val = (4 - mode) & 3; /* {0 1 2 3} -> {0 3 2 1} */ 547 break; 548 default: 549 return -EOPNOTSUPP; 550 } 551 break; 552 case hwmon_fan: 553 switch (attr) { 554 case hwmon_fan_input: 555 /* 556 * Calculation details: 557 * 558 * Each tachometer counts over an interval given by the 559 * "count" register (0.25, 0.5, 1 or 2 seconds). 560 * The driver assumes that the fans produce two pulses 561 * per revolution (this seems to be the most common). 562 */ 563 *val = DIV_ROUND_CLOSEST(data->tach[channel] * 120, 564 DIV_FROM_REG(data->count)); 565 break; 566 case hwmon_fan_div: 567 *val = DIV_FROM_REG(data->count); 568 break; 569 case hwmon_fan_target: 570 /* 571 * Use the datasheet equation: 572 * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)] 573 * then multiply by 60 to give rpm. 574 */ 575 *val = 60 * DIV_FROM_REG(data->config) * clock / 576 (256 * (data->speed + 1)); 577 break; 578 case hwmon_fan_min_alarm: 579 *val = !!(data->alarm & MAX6650_ALRM_MIN); 580 data->alarm &= ~MAX6650_ALRM_MIN; 581 data->valid = false; 582 break; 583 case hwmon_fan_max_alarm: 584 *val = !!(data->alarm & MAX6650_ALRM_MAX); 585 data->alarm &= ~MAX6650_ALRM_MAX; 586 data->valid = false; 587 break; 588 case hwmon_fan_fault: 589 *val = !!(data->alarm & MAX6650_ALRM_TACH); 590 data->alarm &= ~MAX6650_ALRM_TACH; 591 data->valid = false; 592 break; 593 default: 594 return -EOPNOTSUPP; 595 } 596 break; 597 default: 598 return -EOPNOTSUPP; 599 } 600 return 0; 601 } 602 603 static const u8 max6650_pwm_modes[] = { 604 MAX6650_CFG_MODE_ON, 605 MAX6650_CFG_MODE_OPEN_LOOP, 606 MAX6650_CFG_MODE_CLOSED_LOOP, 607 MAX6650_CFG_MODE_OFF, 608 }; 609 610 static int max6650_write(struct device *dev, enum hwmon_sensor_types type, 611 u32 attr, int channel, long val) 612 { 613 struct max6650_data *data = dev_get_drvdata(dev); 614 int ret = 0; 615 u8 reg; 616 617 mutex_lock(&data->update_lock); 618 619 switch (type) { 620 case hwmon_pwm: 621 switch (attr) { 622 case hwmon_pwm_input: 623 reg = pwm_to_dac(clamp_val(val, 0, 255), 624 data->config & MAX6650_CFG_V12); 625 ret = i2c_smbus_write_byte_data(data->client, 626 MAX6650_REG_DAC, reg); 627 if (ret) 628 break; 629 data->dac = reg; 630 break; 631 case hwmon_pwm_enable: 632 if (val < 0 || val >= ARRAY_SIZE(max6650_pwm_modes)) { 633 ret = -EINVAL; 634 break; 635 } 636 ret = max6650_set_operating_mode(data, 637 max6650_pwm_modes[val]); 638 break; 639 default: 640 ret = -EOPNOTSUPP; 641 break; 642 } 643 break; 644 case hwmon_fan: 645 switch (attr) { 646 case hwmon_fan_div: 647 switch (val) { 648 case 1: 649 reg = 0; 650 break; 651 case 2: 652 reg = 1; 653 break; 654 case 4: 655 reg = 2; 656 break; 657 case 8: 658 reg = 3; 659 break; 660 default: 661 ret = -EINVAL; 662 goto error; 663 } 664 ret = i2c_smbus_write_byte_data(data->client, 665 MAX6650_REG_COUNT, reg); 666 if (ret) 667 break; 668 data->count = reg; 669 break; 670 case hwmon_fan_target: 671 if (val < 0) { 672 ret = -EINVAL; 673 break; 674 } 675 ret = max6650_set_target(data, val); 676 break; 677 default: 678 ret = -EOPNOTSUPP; 679 break; 680 } 681 break; 682 default: 683 ret = -EOPNOTSUPP; 684 break; 685 } 686 687 error: 688 mutex_unlock(&data->update_lock); 689 return ret; 690 } 691 692 static umode_t max6650_is_visible(const void *_data, 693 enum hwmon_sensor_types type, u32 attr, 694 int channel) 695 { 696 const struct max6650_data *data = _data; 697 698 if (channel && (channel >= data->nr_fans || type != hwmon_fan)) 699 return 0; 700 701 switch (type) { 702 case hwmon_fan: 703 switch (attr) { 704 case hwmon_fan_input: 705 return 0444; 706 case hwmon_fan_target: 707 case hwmon_fan_div: 708 return 0644; 709 case hwmon_fan_min_alarm: 710 if (data->alarm_en & MAX6650_ALRM_MIN) 711 return 0444; 712 break; 713 case hwmon_fan_max_alarm: 714 if (data->alarm_en & MAX6650_ALRM_MAX) 715 return 0444; 716 break; 717 case hwmon_fan_fault: 718 if (data->alarm_en & MAX6650_ALRM_TACH) 719 return 0444; 720 break; 721 default: 722 break; 723 } 724 break; 725 case hwmon_pwm: 726 switch (attr) { 727 case hwmon_pwm_input: 728 case hwmon_pwm_enable: 729 return 0644; 730 default: 731 break; 732 } 733 break; 734 default: 735 break; 736 } 737 return 0; 738 } 739 740 static const struct hwmon_channel_info *max6650_info[] = { 741 HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_TARGET | HWMON_F_DIV | 742 HWMON_F_MIN_ALARM | HWMON_F_MAX_ALARM | 743 HWMON_F_FAULT, 744 HWMON_F_INPUT, HWMON_F_INPUT, HWMON_F_INPUT), 745 HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE), 746 NULL 747 }; 748 749 static const struct hwmon_ops max6650_hwmon_ops = { 750 .read = max6650_read, 751 .write = max6650_write, 752 .is_visible = max6650_is_visible, 753 }; 754 755 static const struct hwmon_chip_info max6650_chip_info = { 756 .ops = &max6650_hwmon_ops, 757 .info = max6650_info, 758 }; 759 760 static const struct i2c_device_id max6650_id[]; 761 762 static int max6650_probe(struct i2c_client *client) 763 { 764 struct thermal_cooling_device *cooling_dev; 765 struct device *dev = &client->dev; 766 const struct of_device_id *of_id = 767 of_match_device(of_match_ptr(max6650_dt_match), dev); 768 struct max6650_data *data; 769 struct device *hwmon_dev; 770 int err; 771 772 data = devm_kzalloc(dev, sizeof(struct max6650_data), GFP_KERNEL); 773 if (!data) 774 return -ENOMEM; 775 776 data->client = client; 777 i2c_set_clientdata(client, data); 778 mutex_init(&data->update_lock); 779 data->nr_fans = of_id ? (int)(uintptr_t)of_id->data : 780 i2c_match_id(max6650_id, client)->driver_data; 781 782 /* 783 * Initialize the max6650 chip 784 */ 785 err = max6650_init_client(data, client); 786 if (err) 787 return err; 788 789 hwmon_dev = devm_hwmon_device_register_with_info(dev, 790 client->name, data, 791 &max6650_chip_info, 792 max6650_groups); 793 err = PTR_ERR_OR_ZERO(hwmon_dev); 794 if (err) 795 return err; 796 797 if (IS_ENABLED(CONFIG_THERMAL)) { 798 cooling_dev = devm_thermal_of_cooling_device_register(dev, 799 dev->of_node, client->name, 800 data, &max6650_cooling_ops); 801 if (IS_ERR(cooling_dev)) { 802 dev_warn(dev, "thermal cooling device register failed: %ld\n", 803 PTR_ERR(cooling_dev)); 804 } 805 } 806 807 return 0; 808 } 809 810 static const struct i2c_device_id max6650_id[] = { 811 { "max6650", 1 }, 812 { "max6651", 4 }, 813 { } 814 }; 815 MODULE_DEVICE_TABLE(i2c, max6650_id); 816 817 static struct i2c_driver max6650_driver = { 818 .driver = { 819 .name = "max6650", 820 .of_match_table = of_match_ptr(max6650_dt_match), 821 }, 822 .probe_new = max6650_probe, 823 .id_table = max6650_id, 824 }; 825 826 module_i2c_driver(max6650_driver); 827 828 MODULE_AUTHOR("Hans J. Koch"); 829 MODULE_DESCRIPTION("MAX6650 sensor driver"); 830 MODULE_LICENSE("GPL"); 831