1/* 2 * amc6821.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (C) 2009 T. Mertelj <tomaz.mertelj@guest.arnes.si> 5 * 6 * Based on max6650.c: 7 * Copyright (C) 2007 Hans J. Koch <hjk@hansjkoch.de> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 22 */ 23 24#include <linux/kernel.h> /* Needed for KERN_INFO */ 25#include <linux/module.h> 26#include <linux/init.h> 27#include <linux/slab.h> 28#include <linux/jiffies.h> 29#include <linux/i2c.h> 30#include <linux/hwmon.h> 31#include <linux/hwmon-sysfs.h> 32#include <linux/err.h> 33#include <linux/mutex.h> 34 35/* 36 * Addresses to scan. 37 */ 38 39static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e, 40 0x4c, 0x4d, 0x4e, I2C_CLIENT_END}; 41 42/* 43 * Insmod parameters 44 */ 45 46static int pwminv; /*Inverted PWM output. */ 47module_param(pwminv, int, S_IRUGO); 48 49static int init = 1; /*Power-on initialization.*/ 50module_param(init, int, S_IRUGO); 51 52enum chips { amc6821 }; 53 54#define AMC6821_REG_DEV_ID 0x3D 55#define AMC6821_REG_COMP_ID 0x3E 56#define AMC6821_REG_CONF1 0x00 57#define AMC6821_REG_CONF2 0x01 58#define AMC6821_REG_CONF3 0x3F 59#define AMC6821_REG_CONF4 0x04 60#define AMC6821_REG_STAT1 0x02 61#define AMC6821_REG_STAT2 0x03 62#define AMC6821_REG_TDATA_LOW 0x08 63#define AMC6821_REG_TDATA_HI 0x09 64#define AMC6821_REG_LTEMP_HI 0x0A 65#define AMC6821_REG_RTEMP_HI 0x0B 66#define AMC6821_REG_LTEMP_LIMIT_MIN 0x15 67#define AMC6821_REG_LTEMP_LIMIT_MAX 0x14 68#define AMC6821_REG_RTEMP_LIMIT_MIN 0x19 69#define AMC6821_REG_RTEMP_LIMIT_MAX 0x18 70#define AMC6821_REG_LTEMP_CRIT 0x1B 71#define AMC6821_REG_RTEMP_CRIT 0x1D 72#define AMC6821_REG_PSV_TEMP 0x1C 73#define AMC6821_REG_DCY 0x22 74#define AMC6821_REG_LTEMP_FAN_CTRL 0x24 75#define AMC6821_REG_RTEMP_FAN_CTRL 0x25 76#define AMC6821_REG_DCY_LOW_TEMP 0x21 77 78#define AMC6821_REG_TACH_LLIMITL 0x10 79#define AMC6821_REG_TACH_LLIMITH 0x11 80#define AMC6821_REG_TACH_HLIMITL 0x12 81#define AMC6821_REG_TACH_HLIMITH 0x13 82 83#define AMC6821_CONF1_START 0x01 84#define AMC6821_CONF1_FAN_INT_EN 0x02 85#define AMC6821_CONF1_FANIE 0x04 86#define AMC6821_CONF1_PWMINV 0x08 87#define AMC6821_CONF1_FAN_FAULT_EN 0x10 88#define AMC6821_CONF1_FDRC0 0x20 89#define AMC6821_CONF1_FDRC1 0x40 90#define AMC6821_CONF1_THERMOVIE 0x80 91 92#define AMC6821_CONF2_PWM_EN 0x01 93#define AMC6821_CONF2_TACH_MODE 0x02 94#define AMC6821_CONF2_TACH_EN 0x04 95#define AMC6821_CONF2_RTFIE 0x08 96#define AMC6821_CONF2_LTOIE 0x10 97#define AMC6821_CONF2_RTOIE 0x20 98#define AMC6821_CONF2_PSVIE 0x40 99#define AMC6821_CONF2_RST 0x80 100 101#define AMC6821_CONF3_THERM_FAN_EN 0x80 102#define AMC6821_CONF3_REV_MASK 0x0F 103 104#define AMC6821_CONF4_OVREN 0x10 105#define AMC6821_CONF4_TACH_FAST 0x20 106#define AMC6821_CONF4_PSPR 0x40 107#define AMC6821_CONF4_MODE 0x80 108 109#define AMC6821_STAT1_RPM_ALARM 0x01 110#define AMC6821_STAT1_FANS 0x02 111#define AMC6821_STAT1_RTH 0x04 112#define AMC6821_STAT1_RTL 0x08 113#define AMC6821_STAT1_R_THERM 0x10 114#define AMC6821_STAT1_RTF 0x20 115#define AMC6821_STAT1_LTH 0x40 116#define AMC6821_STAT1_LTL 0x80 117 118#define AMC6821_STAT2_RTC 0x08 119#define AMC6821_STAT2_LTC 0x10 120#define AMC6821_STAT2_LPSV 0x20 121#define AMC6821_STAT2_L_THERM 0x40 122#define AMC6821_STAT2_THERM_IN 0x80 123 124enum {IDX_TEMP1_INPUT = 0, IDX_TEMP1_MIN, IDX_TEMP1_MAX, 125 IDX_TEMP1_CRIT, IDX_TEMP2_INPUT, IDX_TEMP2_MIN, 126 IDX_TEMP2_MAX, IDX_TEMP2_CRIT, 127 TEMP_IDX_LEN, }; 128 129static const u8 temp_reg[] = {AMC6821_REG_LTEMP_HI, 130 AMC6821_REG_LTEMP_LIMIT_MIN, 131 AMC6821_REG_LTEMP_LIMIT_MAX, 132 AMC6821_REG_LTEMP_CRIT, 133 AMC6821_REG_RTEMP_HI, 134 AMC6821_REG_RTEMP_LIMIT_MIN, 135 AMC6821_REG_RTEMP_LIMIT_MAX, 136 AMC6821_REG_RTEMP_CRIT, }; 137 138enum {IDX_FAN1_INPUT = 0, IDX_FAN1_MIN, IDX_FAN1_MAX, 139 FAN1_IDX_LEN, }; 140 141static const u8 fan_reg_low[] = {AMC6821_REG_TDATA_LOW, 142 AMC6821_REG_TACH_LLIMITL, 143 AMC6821_REG_TACH_HLIMITL, }; 144 145 146static const u8 fan_reg_hi[] = {AMC6821_REG_TDATA_HI, 147 AMC6821_REG_TACH_LLIMITH, 148 AMC6821_REG_TACH_HLIMITH, }; 149 150/* 151 * Client data (each client gets its own) 152 */ 153 154struct amc6821_data { 155 struct i2c_client *client; 156 struct mutex update_lock; 157 char valid; /* zero until following fields are valid */ 158 unsigned long last_updated; /* in jiffies */ 159 160 /* register values */ 161 int temp[TEMP_IDX_LEN]; 162 163 u16 fan[FAN1_IDX_LEN]; 164 u8 fan1_div; 165 166 u8 pwm1; 167 u8 temp1_auto_point_temp[3]; 168 u8 temp2_auto_point_temp[3]; 169 u8 pwm1_auto_point_pwm[3]; 170 u8 pwm1_enable; 171 u8 pwm1_auto_channels_temp; 172 173 u8 stat1; 174 u8 stat2; 175}; 176 177static struct amc6821_data *amc6821_update_device(struct device *dev) 178{ 179 struct amc6821_data *data = dev_get_drvdata(dev); 180 struct i2c_client *client = data->client; 181 int timeout = HZ; 182 u8 reg; 183 int i; 184 185 mutex_lock(&data->update_lock); 186 187 if (time_after(jiffies, data->last_updated + timeout) || 188 !data->valid) { 189 190 for (i = 0; i < TEMP_IDX_LEN; i++) 191 data->temp[i] = i2c_smbus_read_byte_data(client, 192 temp_reg[i]); 193 194 data->stat1 = i2c_smbus_read_byte_data(client, 195 AMC6821_REG_STAT1); 196 data->stat2 = i2c_smbus_read_byte_data(client, 197 AMC6821_REG_STAT2); 198 199 data->pwm1 = i2c_smbus_read_byte_data(client, 200 AMC6821_REG_DCY); 201 for (i = 0; i < FAN1_IDX_LEN; i++) { 202 data->fan[i] = i2c_smbus_read_byte_data( 203 client, 204 fan_reg_low[i]); 205 data->fan[i] += i2c_smbus_read_byte_data( 206 client, 207 fan_reg_hi[i]) << 8; 208 } 209 data->fan1_div = i2c_smbus_read_byte_data(client, 210 AMC6821_REG_CONF4); 211 data->fan1_div = data->fan1_div & AMC6821_CONF4_PSPR ? 4 : 2; 212 213 data->pwm1_auto_point_pwm[0] = 0; 214 data->pwm1_auto_point_pwm[2] = 255; 215 data->pwm1_auto_point_pwm[1] = i2c_smbus_read_byte_data(client, 216 AMC6821_REG_DCY_LOW_TEMP); 217 218 data->temp1_auto_point_temp[0] = 219 i2c_smbus_read_byte_data(client, 220 AMC6821_REG_PSV_TEMP); 221 data->temp2_auto_point_temp[0] = 222 data->temp1_auto_point_temp[0]; 223 reg = i2c_smbus_read_byte_data(client, 224 AMC6821_REG_LTEMP_FAN_CTRL); 225 data->temp1_auto_point_temp[1] = (reg & 0xF8) >> 1; 226 reg &= 0x07; 227 reg = 0x20 >> reg; 228 if (reg > 0) 229 data->temp1_auto_point_temp[2] = 230 data->temp1_auto_point_temp[1] + 231 (data->pwm1_auto_point_pwm[2] - 232 data->pwm1_auto_point_pwm[1]) / reg; 233 else 234 data->temp1_auto_point_temp[2] = 255; 235 236 reg = i2c_smbus_read_byte_data(client, 237 AMC6821_REG_RTEMP_FAN_CTRL); 238 data->temp2_auto_point_temp[1] = (reg & 0xF8) >> 1; 239 reg &= 0x07; 240 reg = 0x20 >> reg; 241 if (reg > 0) 242 data->temp2_auto_point_temp[2] = 243 data->temp2_auto_point_temp[1] + 244 (data->pwm1_auto_point_pwm[2] - 245 data->pwm1_auto_point_pwm[1]) / reg; 246 else 247 data->temp2_auto_point_temp[2] = 255; 248 249 reg = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1); 250 reg = (reg >> 5) & 0x3; 251 switch (reg) { 252 case 0: /*open loop: software sets pwm1*/ 253 data->pwm1_auto_channels_temp = 0; 254 data->pwm1_enable = 1; 255 break; 256 case 2: /*closed loop: remote T (temp2)*/ 257 data->pwm1_auto_channels_temp = 2; 258 data->pwm1_enable = 2; 259 break; 260 case 3: /*closed loop: local and remote T (temp2)*/ 261 data->pwm1_auto_channels_temp = 3; 262 data->pwm1_enable = 3; 263 break; 264 case 1: /* 265 * semi-open loop: software sets rpm, chip controls 266 * pwm1, currently not implemented 267 */ 268 data->pwm1_auto_channels_temp = 0; 269 data->pwm1_enable = 0; 270 break; 271 } 272 273 data->last_updated = jiffies; 274 data->valid = 1; 275 } 276 mutex_unlock(&data->update_lock); 277 return data; 278} 279 280static ssize_t get_temp( 281 struct device *dev, 282 struct device_attribute *devattr, 283 char *buf) 284{ 285 struct amc6821_data *data = amc6821_update_device(dev); 286 int ix = to_sensor_dev_attr(devattr)->index; 287 288 return sprintf(buf, "%d\n", data->temp[ix] * 1000); 289} 290 291static ssize_t set_temp( 292 struct device *dev, 293 struct device_attribute *attr, 294 const char *buf, 295 size_t count) 296{ 297 struct amc6821_data *data = dev_get_drvdata(dev); 298 struct i2c_client *client = data->client; 299 int ix = to_sensor_dev_attr(attr)->index; 300 long val; 301 302 int ret = kstrtol(buf, 10, &val); 303 if (ret) 304 return ret; 305 val = clamp_val(val / 1000, -128, 127); 306 307 mutex_lock(&data->update_lock); 308 data->temp[ix] = val; 309 if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) { 310 dev_err(&client->dev, "Register write error, aborting.\n"); 311 count = -EIO; 312 } 313 mutex_unlock(&data->update_lock); 314 return count; 315} 316 317static ssize_t get_temp_alarm( 318 struct device *dev, 319 struct device_attribute *devattr, 320 char *buf) 321{ 322 struct amc6821_data *data = amc6821_update_device(dev); 323 int ix = to_sensor_dev_attr(devattr)->index; 324 u8 flag; 325 326 switch (ix) { 327 case IDX_TEMP1_MIN: 328 flag = data->stat1 & AMC6821_STAT1_LTL; 329 break; 330 case IDX_TEMP1_MAX: 331 flag = data->stat1 & AMC6821_STAT1_LTH; 332 break; 333 case IDX_TEMP1_CRIT: 334 flag = data->stat2 & AMC6821_STAT2_LTC; 335 break; 336 case IDX_TEMP2_MIN: 337 flag = data->stat1 & AMC6821_STAT1_RTL; 338 break; 339 case IDX_TEMP2_MAX: 340 flag = data->stat1 & AMC6821_STAT1_RTH; 341 break; 342 case IDX_TEMP2_CRIT: 343 flag = data->stat2 & AMC6821_STAT2_RTC; 344 break; 345 default: 346 dev_dbg(dev, "Unknown attr->index (%d).\n", ix); 347 return -EINVAL; 348 } 349 if (flag) 350 return sprintf(buf, "1"); 351 else 352 return sprintf(buf, "0"); 353} 354 355static ssize_t get_temp2_fault( 356 struct device *dev, 357 struct device_attribute *devattr, 358 char *buf) 359{ 360 struct amc6821_data *data = amc6821_update_device(dev); 361 if (data->stat1 & AMC6821_STAT1_RTF) 362 return sprintf(buf, "1"); 363 else 364 return sprintf(buf, "0"); 365} 366 367static ssize_t get_pwm1( 368 struct device *dev, 369 struct device_attribute *devattr, 370 char *buf) 371{ 372 struct amc6821_data *data = amc6821_update_device(dev); 373 return sprintf(buf, "%d\n", data->pwm1); 374} 375 376static ssize_t set_pwm1( 377 struct device *dev, 378 struct device_attribute *devattr, 379 const char *buf, 380 size_t count) 381{ 382 struct amc6821_data *data = dev_get_drvdata(dev); 383 struct i2c_client *client = data->client; 384 long val; 385 int ret = kstrtol(buf, 10, &val); 386 if (ret) 387 return ret; 388 389 mutex_lock(&data->update_lock); 390 data->pwm1 = clamp_val(val , 0, 255); 391 i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1); 392 mutex_unlock(&data->update_lock); 393 return count; 394} 395 396static ssize_t get_pwm1_enable( 397 struct device *dev, 398 struct device_attribute *devattr, 399 char *buf) 400{ 401 struct amc6821_data *data = amc6821_update_device(dev); 402 return sprintf(buf, "%d\n", data->pwm1_enable); 403} 404 405static ssize_t set_pwm1_enable( 406 struct device *dev, 407 struct device_attribute *attr, 408 const char *buf, 409 size_t count) 410{ 411 struct amc6821_data *data = dev_get_drvdata(dev); 412 struct i2c_client *client = data->client; 413 long val; 414 int config = kstrtol(buf, 10, &val); 415 if (config) 416 return config; 417 418 mutex_lock(&data->update_lock); 419 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1); 420 if (config < 0) { 421 dev_err(&client->dev, 422 "Error reading configuration register, aborting.\n"); 423 count = config; 424 goto unlock; 425 } 426 427 switch (val) { 428 case 1: 429 config &= ~AMC6821_CONF1_FDRC0; 430 config &= ~AMC6821_CONF1_FDRC1; 431 break; 432 case 2: 433 config &= ~AMC6821_CONF1_FDRC0; 434 config |= AMC6821_CONF1_FDRC1; 435 break; 436 case 3: 437 config |= AMC6821_CONF1_FDRC0; 438 config |= AMC6821_CONF1_FDRC1; 439 break; 440 default: 441 count = -EINVAL; 442 goto unlock; 443 } 444 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) { 445 dev_err(&client->dev, 446 "Configuration register write error, aborting.\n"); 447 count = -EIO; 448 } 449unlock: 450 mutex_unlock(&data->update_lock); 451 return count; 452} 453 454static ssize_t get_pwm1_auto_channels_temp( 455 struct device *dev, 456 struct device_attribute *devattr, 457 char *buf) 458{ 459 struct amc6821_data *data = amc6821_update_device(dev); 460 return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp); 461} 462 463static ssize_t get_temp_auto_point_temp( 464 struct device *dev, 465 struct device_attribute *devattr, 466 char *buf) 467{ 468 int ix = to_sensor_dev_attr_2(devattr)->index; 469 int nr = to_sensor_dev_attr_2(devattr)->nr; 470 struct amc6821_data *data = amc6821_update_device(dev); 471 switch (nr) { 472 case 1: 473 return sprintf(buf, "%d\n", 474 data->temp1_auto_point_temp[ix] * 1000); 475 case 2: 476 return sprintf(buf, "%d\n", 477 data->temp2_auto_point_temp[ix] * 1000); 478 default: 479 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr); 480 return -EINVAL; 481 } 482} 483 484static ssize_t get_pwm1_auto_point_pwm( 485 struct device *dev, 486 struct device_attribute *devattr, 487 char *buf) 488{ 489 int ix = to_sensor_dev_attr(devattr)->index; 490 struct amc6821_data *data = amc6821_update_device(dev); 491 return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]); 492} 493 494static inline ssize_t set_slope_register(struct i2c_client *client, 495 u8 reg, 496 u8 dpwm, 497 u8 *ptemp) 498{ 499 int dt; 500 u8 tmp; 501 502 dt = ptemp[2]-ptemp[1]; 503 for (tmp = 4; tmp > 0; tmp--) { 504 if (dt * (0x20 >> tmp) >= dpwm) 505 break; 506 } 507 tmp |= (ptemp[1] & 0x7C) << 1; 508 if (i2c_smbus_write_byte_data(client, 509 reg, tmp)) { 510 dev_err(&client->dev, "Register write error, aborting.\n"); 511 return -EIO; 512 } 513 return 0; 514} 515 516static ssize_t set_temp_auto_point_temp( 517 struct device *dev, 518 struct device_attribute *attr, 519 const char *buf, 520 size_t count) 521{ 522 struct amc6821_data *data = amc6821_update_device(dev); 523 struct i2c_client *client = data->client; 524 int ix = to_sensor_dev_attr_2(attr)->index; 525 int nr = to_sensor_dev_attr_2(attr)->nr; 526 u8 *ptemp; 527 u8 reg; 528 int dpwm; 529 long val; 530 int ret = kstrtol(buf, 10, &val); 531 if (ret) 532 return ret; 533 534 switch (nr) { 535 case 1: 536 ptemp = data->temp1_auto_point_temp; 537 reg = AMC6821_REG_LTEMP_FAN_CTRL; 538 break; 539 case 2: 540 ptemp = data->temp2_auto_point_temp; 541 reg = AMC6821_REG_RTEMP_FAN_CTRL; 542 break; 543 default: 544 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr); 545 return -EINVAL; 546 } 547 548 mutex_lock(&data->update_lock); 549 data->valid = 0; 550 551 switch (ix) { 552 case 0: 553 ptemp[0] = clamp_val(val / 1000, 0, 554 data->temp1_auto_point_temp[1]); 555 ptemp[0] = clamp_val(ptemp[0], 0, 556 data->temp2_auto_point_temp[1]); 557 ptemp[0] = clamp_val(ptemp[0], 0, 63); 558 if (i2c_smbus_write_byte_data( 559 client, 560 AMC6821_REG_PSV_TEMP, 561 ptemp[0])) { 562 dev_err(&client->dev, 563 "Register write error, aborting.\n"); 564 count = -EIO; 565 } 566 goto EXIT; 567 case 1: 568 ptemp[1] = clamp_val(val / 1000, (ptemp[0] & 0x7C) + 4, 124); 569 ptemp[1] &= 0x7C; 570 ptemp[2] = clamp_val(ptemp[2], ptemp[1] + 1, 255); 571 break; 572 case 2: 573 ptemp[2] = clamp_val(val / 1000, ptemp[1]+1, 255); 574 break; 575 default: 576 dev_dbg(dev, "Unknown attr->index (%d).\n", ix); 577 count = -EINVAL; 578 goto EXIT; 579 } 580 dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1]; 581 if (set_slope_register(client, reg, dpwm, ptemp)) 582 count = -EIO; 583 584EXIT: 585 mutex_unlock(&data->update_lock); 586 return count; 587} 588 589static ssize_t set_pwm1_auto_point_pwm( 590 struct device *dev, 591 struct device_attribute *attr, 592 const char *buf, 593 size_t count) 594{ 595 struct amc6821_data *data = dev_get_drvdata(dev); 596 struct i2c_client *client = data->client; 597 int dpwm; 598 long val; 599 int ret = kstrtol(buf, 10, &val); 600 if (ret) 601 return ret; 602 603 mutex_lock(&data->update_lock); 604 data->pwm1_auto_point_pwm[1] = clamp_val(val, 0, 254); 605 if (i2c_smbus_write_byte_data(client, AMC6821_REG_DCY_LOW_TEMP, 606 data->pwm1_auto_point_pwm[1])) { 607 dev_err(&client->dev, "Register write error, aborting.\n"); 608 count = -EIO; 609 goto EXIT; 610 } 611 dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1]; 612 if (set_slope_register(client, AMC6821_REG_LTEMP_FAN_CTRL, dpwm, 613 data->temp1_auto_point_temp)) { 614 count = -EIO; 615 goto EXIT; 616 } 617 if (set_slope_register(client, AMC6821_REG_RTEMP_FAN_CTRL, dpwm, 618 data->temp2_auto_point_temp)) { 619 count = -EIO; 620 goto EXIT; 621 } 622 623EXIT: 624 data->valid = 0; 625 mutex_unlock(&data->update_lock); 626 return count; 627} 628 629static ssize_t get_fan( 630 struct device *dev, 631 struct device_attribute *devattr, 632 char *buf) 633{ 634 struct amc6821_data *data = amc6821_update_device(dev); 635 int ix = to_sensor_dev_attr(devattr)->index; 636 if (0 == data->fan[ix]) 637 return sprintf(buf, "0"); 638 return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix])); 639} 640 641static ssize_t get_fan1_fault( 642 struct device *dev, 643 struct device_attribute *devattr, 644 char *buf) 645{ 646 struct amc6821_data *data = amc6821_update_device(dev); 647 if (data->stat1 & AMC6821_STAT1_FANS) 648 return sprintf(buf, "1"); 649 else 650 return sprintf(buf, "0"); 651} 652 653static ssize_t set_fan( 654 struct device *dev, 655 struct device_attribute *attr, 656 const char *buf, size_t count) 657{ 658 struct amc6821_data *data = dev_get_drvdata(dev); 659 struct i2c_client *client = data->client; 660 long val; 661 int ix = to_sensor_dev_attr(attr)->index; 662 int ret = kstrtol(buf, 10, &val); 663 if (ret) 664 return ret; 665 val = 1 > val ? 0xFFFF : 6000000/val; 666 667 mutex_lock(&data->update_lock); 668 data->fan[ix] = (u16) clamp_val(val, 1, 0xFFFF); 669 if (i2c_smbus_write_byte_data(client, fan_reg_low[ix], 670 data->fan[ix] & 0xFF)) { 671 dev_err(&client->dev, "Register write error, aborting.\n"); 672 count = -EIO; 673 goto EXIT; 674 } 675 if (i2c_smbus_write_byte_data(client, 676 fan_reg_hi[ix], data->fan[ix] >> 8)) { 677 dev_err(&client->dev, "Register write error, aborting.\n"); 678 count = -EIO; 679 } 680EXIT: 681 mutex_unlock(&data->update_lock); 682 return count; 683} 684 685static ssize_t get_fan1_div( 686 struct device *dev, 687 struct device_attribute *devattr, 688 char *buf) 689{ 690 struct amc6821_data *data = amc6821_update_device(dev); 691 return sprintf(buf, "%d\n", data->fan1_div); 692} 693 694static ssize_t set_fan1_div( 695 struct device *dev, 696 struct device_attribute *attr, 697 const char *buf, size_t count) 698{ 699 struct amc6821_data *data = dev_get_drvdata(dev); 700 struct i2c_client *client = data->client; 701 long val; 702 int config = kstrtol(buf, 10, &val); 703 if (config) 704 return config; 705 706 mutex_lock(&data->update_lock); 707 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4); 708 if (config < 0) { 709 dev_err(&client->dev, 710 "Error reading configuration register, aborting.\n"); 711 count = config; 712 goto EXIT; 713 } 714 switch (val) { 715 case 2: 716 config &= ~AMC6821_CONF4_PSPR; 717 data->fan1_div = 2; 718 break; 719 case 4: 720 config |= AMC6821_CONF4_PSPR; 721 data->fan1_div = 4; 722 break; 723 default: 724 count = -EINVAL; 725 goto EXIT; 726 } 727 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) { 728 dev_err(&client->dev, 729 "Configuration register write error, aborting.\n"); 730 count = -EIO; 731 } 732EXIT: 733 mutex_unlock(&data->update_lock); 734 return count; 735} 736 737static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, 738 get_temp, NULL, IDX_TEMP1_INPUT); 739static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, get_temp, 740 set_temp, IDX_TEMP1_MIN); 741static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, get_temp, 742 set_temp, IDX_TEMP1_MAX); 743static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, get_temp, 744 set_temp, IDX_TEMP1_CRIT); 745static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, 746 get_temp_alarm, NULL, IDX_TEMP1_MIN); 747static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, 748 get_temp_alarm, NULL, IDX_TEMP1_MAX); 749static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, 750 get_temp_alarm, NULL, IDX_TEMP1_CRIT); 751static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, 752 get_temp, NULL, IDX_TEMP2_INPUT); 753static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, get_temp, 754 set_temp, IDX_TEMP2_MIN); 755static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, get_temp, 756 set_temp, IDX_TEMP2_MAX); 757static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, get_temp, 758 set_temp, IDX_TEMP2_CRIT); 759static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, 760 get_temp2_fault, NULL, 0); 761static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, 762 get_temp_alarm, NULL, IDX_TEMP2_MIN); 763static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, 764 get_temp_alarm, NULL, IDX_TEMP2_MAX); 765static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, 766 get_temp_alarm, NULL, IDX_TEMP2_CRIT); 767static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, IDX_FAN1_INPUT); 768static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR, 769 get_fan, set_fan, IDX_FAN1_MIN); 770static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO | S_IWUSR, 771 get_fan, set_fan, IDX_FAN1_MAX); 772static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_fan1_fault, NULL, 0); 773static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, 774 get_fan1_div, set_fan1_div, 0); 775 776static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm1, set_pwm1, 0); 777static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, 778 get_pwm1_enable, set_pwm1_enable, 0); 779static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IRUGO, 780 get_pwm1_auto_point_pwm, NULL, 0); 781static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO, 782 get_pwm1_auto_point_pwm, set_pwm1_auto_point_pwm, 1); 783static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IRUGO, 784 get_pwm1_auto_point_pwm, NULL, 2); 785static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IRUGO, 786 get_pwm1_auto_channels_temp, NULL, 0); 787static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO, 788 get_temp_auto_point_temp, NULL, 1, 0); 789static SENSOR_DEVICE_ATTR_2(temp1_auto_point2_temp, S_IWUSR | S_IRUGO, 790 get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 1); 791static SENSOR_DEVICE_ATTR_2(temp1_auto_point3_temp, S_IWUSR | S_IRUGO, 792 get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 2); 793 794static SENSOR_DEVICE_ATTR_2(temp2_auto_point1_temp, S_IWUSR | S_IRUGO, 795 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 0); 796static SENSOR_DEVICE_ATTR_2(temp2_auto_point2_temp, S_IWUSR | S_IRUGO, 797 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 1); 798static SENSOR_DEVICE_ATTR_2(temp2_auto_point3_temp, S_IWUSR | S_IRUGO, 799 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 2); 800 801static struct attribute *amc6821_attrs[] = { 802 &sensor_dev_attr_temp1_input.dev_attr.attr, 803 &sensor_dev_attr_temp1_min.dev_attr.attr, 804 &sensor_dev_attr_temp1_max.dev_attr.attr, 805 &sensor_dev_attr_temp1_crit.dev_attr.attr, 806 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 807 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 808 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 809 &sensor_dev_attr_temp2_input.dev_attr.attr, 810 &sensor_dev_attr_temp2_min.dev_attr.attr, 811 &sensor_dev_attr_temp2_max.dev_attr.attr, 812 &sensor_dev_attr_temp2_crit.dev_attr.attr, 813 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 814 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 815 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 816 &sensor_dev_attr_temp2_fault.dev_attr.attr, 817 &sensor_dev_attr_fan1_input.dev_attr.attr, 818 &sensor_dev_attr_fan1_min.dev_attr.attr, 819 &sensor_dev_attr_fan1_max.dev_attr.attr, 820 &sensor_dev_attr_fan1_fault.dev_attr.attr, 821 &sensor_dev_attr_fan1_div.dev_attr.attr, 822 &sensor_dev_attr_pwm1.dev_attr.attr, 823 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 824 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr, 825 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr, 826 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr, 827 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr, 828 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr, 829 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr, 830 &sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr, 831 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr, 832 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr, 833 &sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr, 834 NULL 835}; 836 837ATTRIBUTE_GROUPS(amc6821); 838 839/* Return 0 if detection is successful, -ENODEV otherwise */ 840static int amc6821_detect( 841 struct i2c_client *client, 842 struct i2c_board_info *info) 843{ 844 struct i2c_adapter *adapter = client->adapter; 845 int address = client->addr; 846 int dev_id, comp_id; 847 848 dev_dbg(&adapter->dev, "amc6821_detect called.\n"); 849 850 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 851 dev_dbg(&adapter->dev, 852 "amc6821: I2C bus doesn't support byte mode, " 853 "skipping.\n"); 854 return -ENODEV; 855 } 856 857 dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID); 858 comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID); 859 if (dev_id != 0x21 || comp_id != 0x49) { 860 dev_dbg(&adapter->dev, 861 "amc6821: detection failed at 0x%02x.\n", 862 address); 863 return -ENODEV; 864 } 865 866 /* 867 * Bit 7 of the address register is ignored, so we can check the 868 * ID registers again 869 */ 870 dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID); 871 comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID); 872 if (dev_id != 0x21 || comp_id != 0x49) { 873 dev_dbg(&adapter->dev, 874 "amc6821: detection failed at 0x%02x.\n", 875 address); 876 return -ENODEV; 877 } 878 879 dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address); 880 strlcpy(info->type, "amc6821", I2C_NAME_SIZE); 881 882 return 0; 883} 884 885static int amc6821_init_client(struct i2c_client *client) 886{ 887 int config; 888 int err = -EIO; 889 890 if (init) { 891 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4); 892 893 if (config < 0) { 894 dev_err(&client->dev, 895 "Error reading configuration register, aborting.\n"); 896 return err; 897 } 898 899 config |= AMC6821_CONF4_MODE; 900 901 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, 902 config)) { 903 dev_err(&client->dev, 904 "Configuration register write error, aborting.\n"); 905 return err; 906 } 907 908 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF3); 909 910 if (config < 0) { 911 dev_err(&client->dev, 912 "Error reading configuration register, aborting.\n"); 913 return err; 914 } 915 916 dev_info(&client->dev, "Revision %d\n", config & 0x0f); 917 918 config &= ~AMC6821_CONF3_THERM_FAN_EN; 919 920 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF3, 921 config)) { 922 dev_err(&client->dev, 923 "Configuration register write error, aborting.\n"); 924 return err; 925 } 926 927 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF2); 928 929 if (config < 0) { 930 dev_err(&client->dev, 931 "Error reading configuration register, aborting.\n"); 932 return err; 933 } 934 935 config &= ~AMC6821_CONF2_RTFIE; 936 config &= ~AMC6821_CONF2_LTOIE; 937 config &= ~AMC6821_CONF2_RTOIE; 938 if (i2c_smbus_write_byte_data(client, 939 AMC6821_REG_CONF2, config)) { 940 dev_err(&client->dev, 941 "Configuration register write error, aborting.\n"); 942 return err; 943 } 944 945 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1); 946 947 if (config < 0) { 948 dev_err(&client->dev, 949 "Error reading configuration register, aborting.\n"); 950 return err; 951 } 952 953 config &= ~AMC6821_CONF1_THERMOVIE; 954 config &= ~AMC6821_CONF1_FANIE; 955 config |= AMC6821_CONF1_START; 956 if (pwminv) 957 config |= AMC6821_CONF1_PWMINV; 958 else 959 config &= ~AMC6821_CONF1_PWMINV; 960 961 if (i2c_smbus_write_byte_data( 962 client, AMC6821_REG_CONF1, config)) { 963 dev_err(&client->dev, 964 "Configuration register write error, aborting.\n"); 965 return err; 966 } 967 } 968 return 0; 969} 970 971static int amc6821_probe(struct i2c_client *client, 972 const struct i2c_device_id *id) 973{ 974 struct device *dev = &client->dev; 975 struct amc6821_data *data; 976 struct device *hwmon_dev; 977 int err; 978 979 data = devm_kzalloc(dev, sizeof(struct amc6821_data), GFP_KERNEL); 980 if (!data) 981 return -ENOMEM; 982 983 data->client = client; 984 mutex_init(&data->update_lock); 985 986 /* 987 * Initialize the amc6821 chip 988 */ 989 err = amc6821_init_client(client); 990 if (err) 991 return err; 992 993 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 994 data, 995 amc6821_groups); 996 return PTR_ERR_OR_ZERO(hwmon_dev); 997} 998 999static const struct i2c_device_id amc6821_id[] = { 1000 { "amc6821", amc6821 }, 1001 { } 1002}; 1003 1004MODULE_DEVICE_TABLE(i2c, amc6821_id); 1005 1006static struct i2c_driver amc6821_driver = { 1007 .class = I2C_CLASS_HWMON, 1008 .driver = { 1009 .name = "amc6821", 1010 }, 1011 .probe = amc6821_probe, 1012 .id_table = amc6821_id, 1013 .detect = amc6821_detect, 1014 .address_list = normal_i2c, 1015}; 1016 1017module_i2c_driver(amc6821_driver); 1018 1019MODULE_LICENSE("GPL"); 1020MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>"); 1021MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver"); 1022