1/* 2 * max6650.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring. 4 * 5 * (C) 2007 by Hans J. Koch <hjk@hansjkoch.de> 6 * 7 * based on code written by John Morris <john.morris@spirentcom.com> 8 * Copyright (c) 2003 Spirent Communications 9 * and Claus Gindhart <claus.gindhart@kontron.com> 10 * 11 * This module has only been tested with the MAX6650 chip. It should 12 * also work with the MAX6651. It does not distinguish max6650 and max6651 13 * chips. 14 * 15 * The datasheet was last seen at: 16 * 17 * http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf 18 * 19 * This program is free software; you can redistribute it and/or modify 20 * it under the terms of the GNU General Public License as published by 21 * the Free Software Foundation; either version 2 of the License, or 22 * (at your option) any later version. 23 * 24 * This program is distributed in the hope that it will be useful, 25 * but WITHOUT ANY WARRANTY; without even the implied warranty of 26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 27 * GNU General Public License for more details. 28 * 29 * You should have received a copy of the GNU General Public License 30 * along with this program; if not, write to the Free Software 31 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 32 */ 33 34#include <linux/module.h> 35#include <linux/init.h> 36#include <linux/slab.h> 37#include <linux/jiffies.h> 38#include <linux/i2c.h> 39#include <linux/hwmon.h> 40#include <linux/hwmon-sysfs.h> 41#include <linux/err.h> 42 43/* 44 * Insmod parameters 45 */ 46 47/* fan_voltage: 5=5V fan, 12=12V fan, 0=don't change */ 48static int fan_voltage; 49/* prescaler: Possible values are 1, 2, 4, 8, 16 or 0 for don't change */ 50static int prescaler; 51/* clock: The clock frequency of the chip the driver should assume */ 52static int clock = 254000; 53 54module_param(fan_voltage, int, S_IRUGO); 55module_param(prescaler, int, S_IRUGO); 56module_param(clock, int, S_IRUGO); 57 58/* 59 * MAX 6650/6651 registers 60 */ 61 62#define MAX6650_REG_SPEED 0x00 63#define MAX6650_REG_CONFIG 0x02 64#define MAX6650_REG_GPIO_DEF 0x04 65#define MAX6650_REG_DAC 0x06 66#define MAX6650_REG_ALARM_EN 0x08 67#define MAX6650_REG_ALARM 0x0A 68#define MAX6650_REG_TACH0 0x0C 69#define MAX6650_REG_TACH1 0x0E 70#define MAX6650_REG_TACH2 0x10 71#define MAX6650_REG_TACH3 0x12 72#define MAX6650_REG_GPIO_STAT 0x14 73#define MAX6650_REG_COUNT 0x16 74 75/* 76 * Config register bits 77 */ 78 79#define MAX6650_CFG_V12 0x08 80#define MAX6650_CFG_PRESCALER_MASK 0x07 81#define MAX6650_CFG_PRESCALER_2 0x01 82#define MAX6650_CFG_PRESCALER_4 0x02 83#define MAX6650_CFG_PRESCALER_8 0x03 84#define MAX6650_CFG_PRESCALER_16 0x04 85#define MAX6650_CFG_MODE_MASK 0x30 86#define MAX6650_CFG_MODE_ON 0x00 87#define MAX6650_CFG_MODE_OFF 0x10 88#define MAX6650_CFG_MODE_CLOSED_LOOP 0x20 89#define MAX6650_CFG_MODE_OPEN_LOOP 0x30 90#define MAX6650_COUNT_MASK 0x03 91 92/* 93 * Alarm status register bits 94 */ 95 96#define MAX6650_ALRM_MAX 0x01 97#define MAX6650_ALRM_MIN 0x02 98#define MAX6650_ALRM_TACH 0x04 99#define MAX6650_ALRM_GPIO1 0x08 100#define MAX6650_ALRM_GPIO2 0x10 101 102/* Minimum and maximum values of the FAN-RPM */ 103#define FAN_RPM_MIN 240 104#define FAN_RPM_MAX 30000 105 106#define DIV_FROM_REG(reg) (1 << (reg & 7)) 107 108/* 109 * Client data (each client gets its own) 110 */ 111 112struct max6650_data { 113 struct i2c_client *client; 114 const struct attribute_group *groups[3]; 115 struct mutex update_lock; 116 int nr_fans; 117 char valid; /* zero until following fields are valid */ 118 unsigned long last_updated; /* in jiffies */ 119 120 /* register values */ 121 u8 speed; 122 u8 config; 123 u8 tach[4]; 124 u8 count; 125 u8 dac; 126 u8 alarm; 127}; 128 129static const u8 tach_reg[] = { 130 MAX6650_REG_TACH0, 131 MAX6650_REG_TACH1, 132 MAX6650_REG_TACH2, 133 MAX6650_REG_TACH3, 134}; 135 136static struct max6650_data *max6650_update_device(struct device *dev) 137{ 138 struct max6650_data *data = dev_get_drvdata(dev); 139 struct i2c_client *client = data->client; 140 int i; 141 142 mutex_lock(&data->update_lock); 143 144 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { 145 data->speed = i2c_smbus_read_byte_data(client, 146 MAX6650_REG_SPEED); 147 data->config = i2c_smbus_read_byte_data(client, 148 MAX6650_REG_CONFIG); 149 for (i = 0; i < data->nr_fans; i++) { 150 data->tach[i] = i2c_smbus_read_byte_data(client, 151 tach_reg[i]); 152 } 153 data->count = i2c_smbus_read_byte_data(client, 154 MAX6650_REG_COUNT); 155 data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC); 156 157 /* 158 * Alarms are cleared on read in case the condition that 159 * caused the alarm is removed. Keep the value latched here 160 * for providing the register through different alarm files. 161 */ 162 data->alarm |= i2c_smbus_read_byte_data(client, 163 MAX6650_REG_ALARM); 164 165 data->last_updated = jiffies; 166 data->valid = 1; 167 } 168 169 mutex_unlock(&data->update_lock); 170 171 return data; 172} 173 174static ssize_t get_fan(struct device *dev, struct device_attribute *devattr, 175 char *buf) 176{ 177 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 178 struct max6650_data *data = max6650_update_device(dev); 179 int rpm; 180 181 /* 182 * Calculation details: 183 * 184 * Each tachometer counts over an interval given by the "count" 185 * register (0.25, 0.5, 1 or 2 seconds). This module assumes 186 * that the fans produce two pulses per revolution (this seems 187 * to be the most common). 188 */ 189 190 rpm = ((data->tach[attr->index] * 120) / DIV_FROM_REG(data->count)); 191 return sprintf(buf, "%d\n", rpm); 192} 193 194/* 195 * Set the fan speed to the specified RPM (or read back the RPM setting). 196 * This works in closed loop mode only. Use pwm1 for open loop speed setting. 197 * 198 * The MAX6650/1 will automatically control fan speed when in closed loop 199 * mode. 200 * 201 * Assumptions: 202 * 203 * 1) The MAX6650/1 internal 254kHz clock frequency is set correctly. Use 204 * the clock module parameter if you need to fine tune this. 205 * 206 * 2) The prescaler (low three bits of the config register) has already 207 * been set to an appropriate value. Use the prescaler module parameter 208 * if your BIOS doesn't initialize the chip properly. 209 * 210 * The relevant equations are given on pages 21 and 22 of the datasheet. 211 * 212 * From the datasheet, the relevant equation when in regulation is: 213 * 214 * [fCLK / (128 x (KTACH + 1))] = 2 x FanSpeed / KSCALE 215 * 216 * where: 217 * 218 * fCLK is the oscillator frequency (either the 254kHz internal 219 * oscillator or the externally applied clock) 220 * 221 * KTACH is the value in the speed register 222 * 223 * FanSpeed is the speed of the fan in rps 224 * 225 * KSCALE is the prescaler value (1, 2, 4, 8, or 16) 226 * 227 * When reading, we need to solve for FanSpeed. When writing, we need to 228 * solve for KTACH. 229 * 230 * Note: this tachometer is completely separate from the tachometers 231 * used to measure the fan speeds. Only one fan's speed (fan1) is 232 * controlled. 233 */ 234 235static ssize_t get_target(struct device *dev, struct device_attribute *devattr, 236 char *buf) 237{ 238 struct max6650_data *data = max6650_update_device(dev); 239 int kscale, ktach, rpm; 240 241 /* 242 * Use the datasheet equation: 243 * 244 * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)] 245 * 246 * then multiply by 60 to give rpm. 247 */ 248 249 kscale = DIV_FROM_REG(data->config); 250 ktach = data->speed; 251 rpm = 60 * kscale * clock / (256 * (ktach + 1)); 252 return sprintf(buf, "%d\n", rpm); 253} 254 255static ssize_t set_target(struct device *dev, struct device_attribute *devattr, 256 const char *buf, size_t count) 257{ 258 struct max6650_data *data = dev_get_drvdata(dev); 259 struct i2c_client *client = data->client; 260 int kscale, ktach; 261 unsigned long rpm; 262 int err; 263 264 err = kstrtoul(buf, 10, &rpm); 265 if (err) 266 return err; 267 268 rpm = clamp_val(rpm, FAN_RPM_MIN, FAN_RPM_MAX); 269 270 /* 271 * Divide the required speed by 60 to get from rpm to rps, then 272 * use the datasheet equation: 273 * 274 * KTACH = [(fCLK x KSCALE) / (256 x FanSpeed)] - 1 275 */ 276 277 mutex_lock(&data->update_lock); 278 279 kscale = DIV_FROM_REG(data->config); 280 ktach = ((clock * kscale) / (256 * rpm / 60)) - 1; 281 if (ktach < 0) 282 ktach = 0; 283 if (ktach > 255) 284 ktach = 255; 285 data->speed = ktach; 286 287 i2c_smbus_write_byte_data(client, MAX6650_REG_SPEED, data->speed); 288 289 mutex_unlock(&data->update_lock); 290 291 return count; 292} 293 294/* 295 * Get/set the fan speed in open loop mode using pwm1 sysfs file. 296 * Speed is given as a relative value from 0 to 255, where 255 is maximum 297 * speed. Note that this is done by writing directly to the chip's DAC, 298 * it won't change the closed loop speed set by fan1_target. 299 * Also note that due to rounding errors it is possible that you don't read 300 * back exactly the value you have set. 301 */ 302 303static ssize_t get_pwm(struct device *dev, struct device_attribute *devattr, 304 char *buf) 305{ 306 int pwm; 307 struct max6650_data *data = max6650_update_device(dev); 308 309 /* 310 * Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans. 311 * Lower DAC values mean higher speeds. 312 */ 313 if (data->config & MAX6650_CFG_V12) 314 pwm = 255 - (255 * (int)data->dac)/180; 315 else 316 pwm = 255 - (255 * (int)data->dac)/76; 317 318 if (pwm < 0) 319 pwm = 0; 320 321 return sprintf(buf, "%d\n", pwm); 322} 323 324static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, 325 const char *buf, size_t count) 326{ 327 struct max6650_data *data = dev_get_drvdata(dev); 328 struct i2c_client *client = data->client; 329 unsigned long pwm; 330 int err; 331 332 err = kstrtoul(buf, 10, &pwm); 333 if (err) 334 return err; 335 336 pwm = clamp_val(pwm, 0, 255); 337 338 mutex_lock(&data->update_lock); 339 340 if (data->config & MAX6650_CFG_V12) 341 data->dac = 180 - (180 * pwm)/255; 342 else 343 data->dac = 76 - (76 * pwm)/255; 344 345 i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac); 346 347 mutex_unlock(&data->update_lock); 348 349 return count; 350} 351 352/* 353 * Get/Set controller mode: 354 * Possible values: 355 * 0 = Fan always on 356 * 1 = Open loop, Voltage is set according to speed, not regulated. 357 * 2 = Closed loop, RPM for all fans regulated by fan1 tachometer 358 */ 359 360static ssize_t get_enable(struct device *dev, struct device_attribute *devattr, 361 char *buf) 362{ 363 struct max6650_data *data = max6650_update_device(dev); 364 int mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4; 365 int sysfs_modes[4] = {0, 1, 2, 1}; 366 367 return sprintf(buf, "%d\n", sysfs_modes[mode]); 368} 369 370static ssize_t set_enable(struct device *dev, struct device_attribute *devattr, 371 const char *buf, size_t count) 372{ 373 struct max6650_data *data = dev_get_drvdata(dev); 374 struct i2c_client *client = data->client; 375 int max6650_modes[3] = {0, 3, 2}; 376 unsigned long mode; 377 int err; 378 379 err = kstrtoul(buf, 10, &mode); 380 if (err) 381 return err; 382 383 if (mode > 2) 384 return -EINVAL; 385 386 mutex_lock(&data->update_lock); 387 388 data->config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG); 389 data->config = (data->config & ~MAX6650_CFG_MODE_MASK) 390 | (max6650_modes[mode] << 4); 391 392 i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, data->config); 393 394 mutex_unlock(&data->update_lock); 395 396 return count; 397} 398 399/* 400 * Read/write functions for fan1_div sysfs file. The MAX6650 has no such 401 * divider. We handle this by converting between divider and counttime: 402 * 403 * (counttime == k) <==> (divider == 2^k), k = 0, 1, 2, or 3 404 * 405 * Lower values of k allow to connect a faster fan without the risk of 406 * counter overflow. The price is lower resolution. You can also set counttime 407 * using the module parameter. Note that the module parameter "prescaler" also 408 * influences the behaviour. Unfortunately, there's no sysfs attribute 409 * defined for that. See the data sheet for details. 410 */ 411 412static ssize_t get_div(struct device *dev, struct device_attribute *devattr, 413 char *buf) 414{ 415 struct max6650_data *data = max6650_update_device(dev); 416 417 return sprintf(buf, "%d\n", DIV_FROM_REG(data->count)); 418} 419 420static ssize_t set_div(struct device *dev, struct device_attribute *devattr, 421 const char *buf, size_t count) 422{ 423 struct max6650_data *data = dev_get_drvdata(dev); 424 struct i2c_client *client = data->client; 425 unsigned long div; 426 int err; 427 428 err = kstrtoul(buf, 10, &div); 429 if (err) 430 return err; 431 432 mutex_lock(&data->update_lock); 433 switch (div) { 434 case 1: 435 data->count = 0; 436 break; 437 case 2: 438 data->count = 1; 439 break; 440 case 4: 441 data->count = 2; 442 break; 443 case 8: 444 data->count = 3; 445 break; 446 default: 447 mutex_unlock(&data->update_lock); 448 return -EINVAL; 449 } 450 451 i2c_smbus_write_byte_data(client, MAX6650_REG_COUNT, data->count); 452 mutex_unlock(&data->update_lock); 453 454 return count; 455} 456 457/* 458 * Get alarm stati: 459 * Possible values: 460 * 0 = no alarm 461 * 1 = alarm 462 */ 463 464static ssize_t get_alarm(struct device *dev, struct device_attribute *devattr, 465 char *buf) 466{ 467 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); 468 struct max6650_data *data = max6650_update_device(dev); 469 struct i2c_client *client = data->client; 470 int alarm = 0; 471 472 if (data->alarm & attr->index) { 473 mutex_lock(&data->update_lock); 474 alarm = 1; 475 data->alarm &= ~attr->index; 476 data->alarm |= i2c_smbus_read_byte_data(client, 477 MAX6650_REG_ALARM); 478 mutex_unlock(&data->update_lock); 479 } 480 481 return sprintf(buf, "%d\n", alarm); 482} 483 484static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, 0); 485static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan, NULL, 1); 486static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, get_fan, NULL, 2); 487static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, get_fan, NULL, 3); 488static DEVICE_ATTR(fan1_target, S_IWUSR | S_IRUGO, get_target, set_target); 489static DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, get_div, set_div); 490static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, get_enable, set_enable); 491static DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm, set_pwm); 492static SENSOR_DEVICE_ATTR(fan1_max_alarm, S_IRUGO, get_alarm, NULL, 493 MAX6650_ALRM_MAX); 494static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, get_alarm, NULL, 495 MAX6650_ALRM_MIN); 496static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_alarm, NULL, 497 MAX6650_ALRM_TACH); 498static SENSOR_DEVICE_ATTR(gpio1_alarm, S_IRUGO, get_alarm, NULL, 499 MAX6650_ALRM_GPIO1); 500static SENSOR_DEVICE_ATTR(gpio2_alarm, S_IRUGO, get_alarm, NULL, 501 MAX6650_ALRM_GPIO2); 502 503static umode_t max6650_attrs_visible(struct kobject *kobj, struct attribute *a, 504 int n) 505{ 506 struct device *dev = container_of(kobj, struct device, kobj); 507 struct max6650_data *data = dev_get_drvdata(dev); 508 struct i2c_client *client = data->client; 509 u8 alarm_en = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN); 510 struct device_attribute *devattr; 511 512 /* 513 * Hide the alarms that have not been enabled by the firmware 514 */ 515 516 devattr = container_of(a, struct device_attribute, attr); 517 if (devattr == &sensor_dev_attr_fan1_max_alarm.dev_attr 518 || devattr == &sensor_dev_attr_fan1_min_alarm.dev_attr 519 || devattr == &sensor_dev_attr_fan1_fault.dev_attr 520 || devattr == &sensor_dev_attr_gpio1_alarm.dev_attr 521 || devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) { 522 if (!(alarm_en & to_sensor_dev_attr(devattr)->index)) 523 return 0; 524 } 525 526 return a->mode; 527} 528 529static struct attribute *max6650_attrs[] = { 530 &sensor_dev_attr_fan1_input.dev_attr.attr, 531 &dev_attr_fan1_target.attr, 532 &dev_attr_fan1_div.attr, 533 &dev_attr_pwm1_enable.attr, 534 &dev_attr_pwm1.attr, 535 &sensor_dev_attr_fan1_max_alarm.dev_attr.attr, 536 &sensor_dev_attr_fan1_min_alarm.dev_attr.attr, 537 &sensor_dev_attr_fan1_fault.dev_attr.attr, 538 &sensor_dev_attr_gpio1_alarm.dev_attr.attr, 539 &sensor_dev_attr_gpio2_alarm.dev_attr.attr, 540 NULL 541}; 542 543static const struct attribute_group max6650_group = { 544 .attrs = max6650_attrs, 545 .is_visible = max6650_attrs_visible, 546}; 547 548static struct attribute *max6651_attrs[] = { 549 &sensor_dev_attr_fan2_input.dev_attr.attr, 550 &sensor_dev_attr_fan3_input.dev_attr.attr, 551 &sensor_dev_attr_fan4_input.dev_attr.attr, 552 NULL 553}; 554 555static const struct attribute_group max6651_group = { 556 .attrs = max6651_attrs, 557}; 558 559/* 560 * Real code 561 */ 562 563static int max6650_init_client(struct max6650_data *data, 564 struct i2c_client *client) 565{ 566 struct device *dev = &client->dev; 567 int config; 568 int err = -EIO; 569 570 config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG); 571 572 if (config < 0) { 573 dev_err(dev, "Error reading config, aborting.\n"); 574 return err; 575 } 576 577 switch (fan_voltage) { 578 case 0: 579 break; 580 case 5: 581 config &= ~MAX6650_CFG_V12; 582 break; 583 case 12: 584 config |= MAX6650_CFG_V12; 585 break; 586 default: 587 dev_err(dev, "illegal value for fan_voltage (%d)\n", 588 fan_voltage); 589 } 590 591 dev_info(dev, "Fan voltage is set to %dV.\n", 592 (config & MAX6650_CFG_V12) ? 12 : 5); 593 594 switch (prescaler) { 595 case 0: 596 break; 597 case 1: 598 config &= ~MAX6650_CFG_PRESCALER_MASK; 599 break; 600 case 2: 601 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 602 | MAX6650_CFG_PRESCALER_2; 603 break; 604 case 4: 605 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 606 | MAX6650_CFG_PRESCALER_4; 607 break; 608 case 8: 609 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 610 | MAX6650_CFG_PRESCALER_8; 611 break; 612 case 16: 613 config = (config & ~MAX6650_CFG_PRESCALER_MASK) 614 | MAX6650_CFG_PRESCALER_16; 615 break; 616 default: 617 dev_err(dev, "illegal value for prescaler (%d)\n", prescaler); 618 } 619 620 dev_info(dev, "Prescaler is set to %d.\n", 621 1 << (config & MAX6650_CFG_PRESCALER_MASK)); 622 623 /* 624 * If mode is set to "full off", we change it to "open loop" and 625 * set DAC to 255, which has the same effect. We do this because 626 * there's no "full off" mode defined in hwmon specifications. 627 */ 628 629 if ((config & MAX6650_CFG_MODE_MASK) == MAX6650_CFG_MODE_OFF) { 630 dev_dbg(dev, "Change mode to open loop, full off.\n"); 631 config = (config & ~MAX6650_CFG_MODE_MASK) 632 | MAX6650_CFG_MODE_OPEN_LOOP; 633 if (i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, 255)) { 634 dev_err(dev, "DAC write error, aborting.\n"); 635 return err; 636 } 637 } 638 639 if (i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, config)) { 640 dev_err(dev, "Config write error, aborting.\n"); 641 return err; 642 } 643 644 data->config = config; 645 data->count = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT); 646 647 return 0; 648} 649 650static int max6650_probe(struct i2c_client *client, 651 const struct i2c_device_id *id) 652{ 653 struct device *dev = &client->dev; 654 struct max6650_data *data; 655 struct device *hwmon_dev; 656 int err; 657 658 data = devm_kzalloc(dev, sizeof(struct max6650_data), GFP_KERNEL); 659 if (!data) 660 return -ENOMEM; 661 662 data->client = client; 663 mutex_init(&data->update_lock); 664 data->nr_fans = id->driver_data; 665 666 /* 667 * Initialize the max6650 chip 668 */ 669 err = max6650_init_client(data, client); 670 if (err) 671 return err; 672 673 data->groups[0] = &max6650_group; 674 /* 3 additional fan inputs for the MAX6651 */ 675 if (data->nr_fans == 4) 676 data->groups[1] = &max6651_group; 677 678 hwmon_dev = devm_hwmon_device_register_with_groups(dev, 679 client->name, data, 680 data->groups); 681 return PTR_ERR_OR_ZERO(hwmon_dev); 682} 683 684static const struct i2c_device_id max6650_id[] = { 685 { "max6650", 1 }, 686 { "max6651", 4 }, 687 { } 688}; 689MODULE_DEVICE_TABLE(i2c, max6650_id); 690 691static struct i2c_driver max6650_driver = { 692 .driver = { 693 .name = "max6650", 694 }, 695 .probe = max6650_probe, 696 .id_table = max6650_id, 697}; 698 699module_i2c_driver(max6650_driver); 700 701MODULE_AUTHOR("Hans J. Koch"); 702MODULE_DESCRIPTION("MAX6650 sensor driver"); 703MODULE_LICENSE("GPL"); 704