/drivers/hwmon/f75375s.c
C | 718 lines | 594 code | 86 blank | 38 comment | 46 complexity | be6d8a6f420cff8c69eda49ebe7256a1 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
1/* 2 * f75375s.c - driver for the Fintek F75375/SP and F75373 3 * hardware monitoring features 4 * Copyright (C) 2006-2007 Riku Voipio 5 * 6 * Datasheets available at: 7 * 8 * f75375: 9 * http://www.fintek.com.tw/files/productfiles/F75375_V026P.pdf 10 * 11 * f75373: 12 * http://www.fintek.com.tw/files/productfiles/F75373_V025P.pdf 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License as published by 16 * the Free Software Foundation; either version 2 of the License, or 17 * (at your option) any later version. 18 * 19 * This program is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 * GNU General Public License for more details. 23 * 24 * You should have received a copy of the GNU General Public License 25 * along with this program; if not, write to the Free Software 26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 27 * 28 */ 29 30#include <linux/module.h> 31#include <linux/jiffies.h> 32#include <linux/hwmon.h> 33#include <linux/hwmon-sysfs.h> 34#include <linux/i2c.h> 35#include <linux/err.h> 36#include <linux/mutex.h> 37#include <linux/f75375s.h> 38#include <linux/slab.h> 39 40/* Addresses to scan */ 41static const unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END }; 42 43enum chips { f75373, f75375 }; 44 45/* Fintek F75375 registers */ 46#define F75375_REG_CONFIG0 0x0 47#define F75375_REG_CONFIG1 0x1 48#define F75375_REG_CONFIG2 0x2 49#define F75375_REG_CONFIG3 0x3 50#define F75375_REG_ADDR 0x4 51#define F75375_REG_INTR 0x31 52#define F75375_CHIP_ID 0x5A 53#define F75375_REG_VERSION 0x5C 54#define F75375_REG_VENDOR 0x5D 55#define F75375_REG_FAN_TIMER 0x60 56 57#define F75375_REG_VOLT(nr) (0x10 + (nr)) 58#define F75375_REG_VOLT_HIGH(nr) (0x20 + (nr) * 2) 59#define F75375_REG_VOLT_LOW(nr) (0x21 + (nr) * 2) 60 61#define F75375_REG_TEMP(nr) (0x14 + (nr)) 62#define F75375_REG_TEMP_HIGH(nr) (0x28 + (nr) * 2) 63#define F75375_REG_TEMP_HYST(nr) (0x29 + (nr) * 2) 64 65#define F75375_REG_FAN(nr) (0x16 + (nr) * 2) 66#define F75375_REG_FAN_MIN(nr) (0x2C + (nr) * 2) 67#define F75375_REG_FAN_FULL(nr) (0x70 + (nr) * 0x10) 68#define F75375_REG_FAN_PWM_DUTY(nr) (0x76 + (nr) * 0x10) 69#define F75375_REG_FAN_PWM_CLOCK(nr) (0x7D + (nr) * 0x10) 70 71#define F75375_REG_FAN_EXP(nr) (0x74 + (nr) * 0x10) 72#define F75375_REG_FAN_B_TEMP(nr, step) ((0xA0 + (nr) * 0x10) + (step)) 73#define F75375_REG_FAN_B_SPEED(nr, step) \ 74 ((0xA5 + (nr) * 0x10) + (step) * 2) 75 76#define F75375_REG_PWM1_RAISE_DUTY 0x69 77#define F75375_REG_PWM2_RAISE_DUTY 0x6A 78#define F75375_REG_PWM1_DROP_DUTY 0x6B 79#define F75375_REG_PWM2_DROP_DUTY 0x6C 80 81#define FAN_CTRL_LINEAR(nr) (4 + nr) 82#define FAN_CTRL_MODE(nr) (4 + ((nr) * 2)) 83 84/* 85 * Data structures and manipulation thereof 86 */ 87 88struct f75375_data { 89 unsigned short addr; 90 struct device *hwmon_dev; 91 92 const char *name; 93 int kind; 94 struct mutex update_lock; /* protect register access */ 95 char valid; 96 unsigned long last_updated; /* In jiffies */ 97 unsigned long last_limits; /* In jiffies */ 98 99 /* Register values */ 100 u8 in[4]; 101 u8 in_max[4]; 102 u8 in_min[4]; 103 u16 fan[2]; 104 u16 fan_min[2]; 105 u16 fan_full[2]; 106 u16 fan_exp[2]; 107 u8 fan_timer; 108 u8 pwm[2]; 109 u8 pwm_mode[2]; 110 u8 pwm_enable[2]; 111 s8 temp[2]; 112 s8 temp_high[2]; 113 s8 temp_max_hyst[2]; 114}; 115 116static int f75375_detect(struct i2c_client *client, 117 struct i2c_board_info *info); 118static int f75375_probe(struct i2c_client *client, 119 const struct i2c_device_id *id); 120static int f75375_remove(struct i2c_client *client); 121 122static const struct i2c_device_id f75375_id[] = { 123 { "f75373", f75373 }, 124 { "f75375", f75375 }, 125 { } 126}; 127MODULE_DEVICE_TABLE(i2c, f75375_id); 128 129static struct i2c_driver f75375_driver = { 130 .class = I2C_CLASS_HWMON, 131 .driver = { 132 .name = "f75375", 133 }, 134 .probe = f75375_probe, 135 .remove = f75375_remove, 136 .id_table = f75375_id, 137 .detect = f75375_detect, 138 .address_list = normal_i2c, 139}; 140 141static inline int f75375_read8(struct i2c_client *client, u8 reg) 142{ 143 return i2c_smbus_read_byte_data(client, reg); 144} 145 146/* in most cases, should be called while holding update_lock */ 147static inline u16 f75375_read16(struct i2c_client *client, u8 reg) 148{ 149 return ((i2c_smbus_read_byte_data(client, reg) << 8) 150 | i2c_smbus_read_byte_data(client, reg + 1)); 151} 152 153static inline void f75375_write8(struct i2c_client *client, u8 reg, 154 u8 value) 155{ 156 i2c_smbus_write_byte_data(client, reg, value); 157} 158 159static inline void f75375_write16(struct i2c_client *client, u8 reg, 160 u16 value) 161{ 162 int err = i2c_smbus_write_byte_data(client, reg, (value >> 8)); 163 if (err) 164 return; 165 i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF)); 166} 167 168static struct f75375_data *f75375_update_device(struct device *dev) 169{ 170 struct i2c_client *client = to_i2c_client(dev); 171 struct f75375_data *data = i2c_get_clientdata(client); 172 int nr; 173 174 mutex_lock(&data->update_lock); 175 176 /* Limit registers cache is refreshed after 60 seconds */ 177 if (time_after(jiffies, data->last_limits + 60 * HZ) 178 || !data->valid) { 179 for (nr = 0; nr < 2; nr++) { 180 data->temp_high[nr] = 181 f75375_read8(client, F75375_REG_TEMP_HIGH(nr)); 182 data->temp_max_hyst[nr] = 183 f75375_read8(client, F75375_REG_TEMP_HYST(nr)); 184 data->fan_full[nr] = 185 f75375_read16(client, F75375_REG_FAN_FULL(nr)); 186 data->fan_min[nr] = 187 f75375_read16(client, F75375_REG_FAN_MIN(nr)); 188 data->fan_exp[nr] = 189 f75375_read16(client, F75375_REG_FAN_EXP(nr)); 190 data->pwm[nr] = f75375_read8(client, 191 F75375_REG_FAN_PWM_DUTY(nr)); 192 193 } 194 for (nr = 0; nr < 4; nr++) { 195 data->in_max[nr] = 196 f75375_read8(client, F75375_REG_VOLT_HIGH(nr)); 197 data->in_min[nr] = 198 f75375_read8(client, F75375_REG_VOLT_LOW(nr)); 199 } 200 data->fan_timer = f75375_read8(client, F75375_REG_FAN_TIMER); 201 data->last_limits = jiffies; 202 } 203 204 /* Measurement registers cache is refreshed after 2 second */ 205 if (time_after(jiffies, data->last_updated + 2 * HZ) 206 || !data->valid) { 207 for (nr = 0; nr < 2; nr++) { 208 data->temp[nr] = 209 f75375_read8(client, F75375_REG_TEMP(nr)); 210 data->fan[nr] = 211 f75375_read16(client, F75375_REG_FAN(nr)); 212 } 213 for (nr = 0; nr < 4; nr++) 214 data->in[nr] = 215 f75375_read8(client, F75375_REG_VOLT(nr)); 216 217 data->last_updated = jiffies; 218 data->valid = 1; 219 } 220 221 mutex_unlock(&data->update_lock); 222 return data; 223} 224 225static inline u16 rpm_from_reg(u16 reg) 226{ 227 if (reg == 0 || reg == 0xffff) 228 return 0; 229 return (1500000 / reg); 230} 231 232static inline u16 rpm_to_reg(int rpm) 233{ 234 if (rpm < 367 || rpm > 0xffff) 235 return 0xffff; 236 return (1500000 / rpm); 237} 238 239static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 240 const char *buf, size_t count) 241{ 242 int nr = to_sensor_dev_attr(attr)->index; 243 struct i2c_client *client = to_i2c_client(dev); 244 struct f75375_data *data = i2c_get_clientdata(client); 245 int val = simple_strtoul(buf, NULL, 10); 246 247 mutex_lock(&data->update_lock); 248 data->fan_min[nr] = rpm_to_reg(val); 249 f75375_write16(client, F75375_REG_FAN_MIN(nr), data->fan_min[nr]); 250 mutex_unlock(&data->update_lock); 251 return count; 252} 253 254static ssize_t set_fan_exp(struct device *dev, struct device_attribute *attr, 255 const char *buf, size_t count) 256{ 257 int nr = to_sensor_dev_attr(attr)->index; 258 struct i2c_client *client = to_i2c_client(dev); 259 struct f75375_data *data = i2c_get_clientdata(client); 260 int val = simple_strtoul(buf, NULL, 10); 261 262 mutex_lock(&data->update_lock); 263 data->fan_exp[nr] = rpm_to_reg(val); 264 f75375_write16(client, F75375_REG_FAN_EXP(nr), data->fan_exp[nr]); 265 mutex_unlock(&data->update_lock); 266 return count; 267} 268 269static ssize_t set_pwm(struct device *dev, struct device_attribute *attr, 270 const char *buf, size_t count) 271{ 272 int nr = to_sensor_dev_attr(attr)->index; 273 struct i2c_client *client = to_i2c_client(dev); 274 struct f75375_data *data = i2c_get_clientdata(client); 275 int val = simple_strtoul(buf, NULL, 10); 276 277 mutex_lock(&data->update_lock); 278 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255); 279 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr), data->pwm[nr]); 280 mutex_unlock(&data->update_lock); 281 return count; 282} 283 284static ssize_t show_pwm_enable(struct device *dev, struct device_attribute 285 *attr, char *buf) 286{ 287 int nr = to_sensor_dev_attr(attr)->index; 288 struct f75375_data *data = f75375_update_device(dev); 289 return sprintf(buf, "%d\n", data->pwm_enable[nr]); 290} 291 292static int set_pwm_enable_direct(struct i2c_client *client, int nr, int val) 293{ 294 struct f75375_data *data = i2c_get_clientdata(client); 295 u8 fanmode; 296 297 if (val < 0 || val > 4) 298 return -EINVAL; 299 300 fanmode = f75375_read8(client, F75375_REG_FAN_TIMER); 301 fanmode &= ~(3 << FAN_CTRL_MODE(nr)); 302 303 switch (val) { 304 case 0: /* Full speed */ 305 fanmode |= (3 << FAN_CTRL_MODE(nr)); 306 data->pwm[nr] = 255; 307 break; 308 case 1: /* PWM */ 309 fanmode |= (3 << FAN_CTRL_MODE(nr)); 310 break; 311 case 2: /* AUTOMATIC*/ 312 fanmode |= (1 << FAN_CTRL_MODE(nr)); 313 break; 314 case 3: /* fan speed */ 315 break; 316 } 317 f75375_write8(client, F75375_REG_FAN_TIMER, fanmode); 318 data->pwm_enable[nr] = val; 319 if (val == 0) 320 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr), 321 data->pwm[nr]); 322 return 0; 323} 324 325static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr, 326 const char *buf, size_t count) 327{ 328 int nr = to_sensor_dev_attr(attr)->index; 329 struct i2c_client *client = to_i2c_client(dev); 330 struct f75375_data *data = i2c_get_clientdata(client); 331 int val = simple_strtoul(buf, NULL, 10); 332 int err = 0; 333 334 mutex_lock(&data->update_lock); 335 err = set_pwm_enable_direct(client, nr, val); 336 mutex_unlock(&data->update_lock); 337 return err ? err : count; 338} 339 340static ssize_t set_pwm_mode(struct device *dev, struct device_attribute *attr, 341 const char *buf, size_t count) 342{ 343 int nr = to_sensor_dev_attr(attr)->index; 344 struct i2c_client *client = to_i2c_client(dev); 345 struct f75375_data *data = i2c_get_clientdata(client); 346 int val = simple_strtoul(buf, NULL, 10); 347 u8 conf = 0; 348 349 if (!(val == 0 || val == 1)) 350 return -EINVAL; 351 352 mutex_lock(&data->update_lock); 353 conf = f75375_read8(client, F75375_REG_CONFIG1); 354 conf &= ~(1 << FAN_CTRL_LINEAR(nr)); 355 356 if (val == 0) 357 conf |= (1 << FAN_CTRL_LINEAR(nr)) ; 358 359 f75375_write8(client, F75375_REG_CONFIG1, conf); 360 data->pwm_mode[nr] = val; 361 mutex_unlock(&data->update_lock); 362 return count; 363} 364 365static ssize_t show_pwm(struct device *dev, struct device_attribute 366 *attr, char *buf) 367{ 368 int nr = to_sensor_dev_attr(attr)->index; 369 struct f75375_data *data = f75375_update_device(dev); 370 return sprintf(buf, "%d\n", data->pwm[nr]); 371} 372 373static ssize_t show_pwm_mode(struct device *dev, struct device_attribute 374 *attr, char *buf) 375{ 376 int nr = to_sensor_dev_attr(attr)->index; 377 struct f75375_data *data = f75375_update_device(dev); 378 return sprintf(buf, "%d\n", data->pwm_mode[nr]); 379} 380 381#define VOLT_FROM_REG(val) ((val) * 8) 382#define VOLT_TO_REG(val) ((val) / 8) 383 384static ssize_t show_in(struct device *dev, struct device_attribute *attr, 385 char *buf) 386{ 387 int nr = to_sensor_dev_attr(attr)->index; 388 struct f75375_data *data = f75375_update_device(dev); 389 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in[nr])); 390} 391 392static ssize_t show_in_max(struct device *dev, struct device_attribute *attr, 393 char *buf) 394{ 395 int nr = to_sensor_dev_attr(attr)->index; 396 struct f75375_data *data = f75375_update_device(dev); 397 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_max[nr])); 398} 399 400static ssize_t show_in_min(struct device *dev, struct device_attribute *attr, 401 char *buf) 402{ 403 int nr = to_sensor_dev_attr(attr)->index; 404 struct f75375_data *data = f75375_update_device(dev); 405 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_min[nr])); 406} 407 408static ssize_t set_in_max(struct device *dev, struct device_attribute *attr, 409 const char *buf, size_t count) 410{ 411 int nr = to_sensor_dev_attr(attr)->index; 412 struct i2c_client *client = to_i2c_client(dev); 413 struct f75375_data *data = i2c_get_clientdata(client); 414 int val = simple_strtoul(buf, NULL, 10); 415 val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff); 416 mutex_lock(&data->update_lock); 417 data->in_max[nr] = val; 418 f75375_write8(client, F75375_REG_VOLT_HIGH(nr), data->in_max[nr]); 419 mutex_unlock(&data->update_lock); 420 return count; 421} 422 423static ssize_t set_in_min(struct device *dev, struct device_attribute *attr, 424 const char *buf, size_t count) 425{ 426 int nr = to_sensor_dev_attr(attr)->index; 427 struct i2c_client *client = to_i2c_client(dev); 428 struct f75375_data *data = i2c_get_clientdata(client); 429 int val = simple_strtoul(buf, NULL, 10); 430 val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff); 431 mutex_lock(&data->update_lock); 432 data->in_min[nr] = val; 433 f75375_write8(client, F75375_REG_VOLT_LOW(nr), data->in_min[nr]); 434 mutex_unlock(&data->update_lock); 435 return count; 436} 437#define TEMP_FROM_REG(val) ((val) * 1000) 438#define TEMP_TO_REG(val) ((val) / 1000) 439 440static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 441 char *buf) 442{ 443 int nr = to_sensor_dev_attr(attr)->index; 444 struct f75375_data *data = f75375_update_device(dev); 445 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr])); 446} 447 448static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr, 449 char *buf) 450{ 451 int nr = to_sensor_dev_attr(attr)->index; 452 struct f75375_data *data = f75375_update_device(dev); 453 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr])); 454} 455 456static ssize_t show_temp_max_hyst(struct device *dev, 457 struct device_attribute *attr, char *buf) 458{ 459 int nr = to_sensor_dev_attr(attr)->index; 460 struct f75375_data *data = f75375_update_device(dev); 461 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[nr])); 462} 463 464static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 465 const char *buf, size_t count) 466{ 467 int nr = to_sensor_dev_attr(attr)->index; 468 struct i2c_client *client = to_i2c_client(dev); 469 struct f75375_data *data = i2c_get_clientdata(client); 470 int val = simple_strtol(buf, NULL, 10); 471 val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127); 472 mutex_lock(&data->update_lock); 473 data->temp_high[nr] = val; 474 f75375_write8(client, F75375_REG_TEMP_HIGH(nr), data->temp_high[nr]); 475 mutex_unlock(&data->update_lock); 476 return count; 477} 478 479static ssize_t set_temp_max_hyst(struct device *dev, 480 struct device_attribute *attr, const char *buf, size_t count) 481{ 482 int nr = to_sensor_dev_attr(attr)->index; 483 struct i2c_client *client = to_i2c_client(dev); 484 struct f75375_data *data = i2c_get_clientdata(client); 485 int val = simple_strtol(buf, NULL, 10); 486 val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127); 487 mutex_lock(&data->update_lock); 488 data->temp_max_hyst[nr] = val; 489 f75375_write8(client, F75375_REG_TEMP_HYST(nr), 490 data->temp_max_hyst[nr]); 491 mutex_unlock(&data->update_lock); 492 return count; 493} 494 495#define show_fan(thing) \ 496static ssize_t show_##thing(struct device *dev, struct device_attribute *attr, \ 497 char *buf)\ 498{\ 499 int nr = to_sensor_dev_attr(attr)->index;\ 500 struct f75375_data *data = f75375_update_device(dev); \ 501 return sprintf(buf, "%d\n", rpm_from_reg(data->thing[nr])); \ 502} 503 504show_fan(fan); 505show_fan(fan_min); 506show_fan(fan_full); 507show_fan(fan_exp); 508 509static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0); 510static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR, 511 show_in_max, set_in_max, 0); 512static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR, 513 show_in_min, set_in_min, 0); 514static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1); 515static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR, 516 show_in_max, set_in_max, 1); 517static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR, 518 show_in_min, set_in_min, 1); 519static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2); 520static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR, 521 show_in_max, set_in_max, 2); 522static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR, 523 show_in_min, set_in_min, 2); 524static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3); 525static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR, 526 show_in_max, set_in_max, 3); 527static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR, 528 show_in_min, set_in_min, 3); 529static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 530static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR, 531 show_temp_max_hyst, set_temp_max_hyst, 0); 532static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR, 533 show_temp_max, set_temp_max, 0); 534static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 535static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR, 536 show_temp_max_hyst, set_temp_max_hyst, 1); 537static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR, 538 show_temp_max, set_temp_max, 1); 539static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0); 540static SENSOR_DEVICE_ATTR(fan1_full, S_IRUGO, show_fan_full, NULL, 0); 541static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR, 542 show_fan_min, set_fan_min, 0); 543static SENSOR_DEVICE_ATTR(fan1_exp, S_IRUGO|S_IWUSR, 544 show_fan_exp, set_fan_exp, 0); 545static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1); 546static SENSOR_DEVICE_ATTR(fan2_full, S_IRUGO, show_fan_full, NULL, 1); 547static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR, 548 show_fan_min, set_fan_min, 1); 549static SENSOR_DEVICE_ATTR(fan2_exp, S_IRUGO|S_IWUSR, 550 show_fan_exp, set_fan_exp, 1); 551static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR, 552 show_pwm, set_pwm, 0); 553static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR, 554 show_pwm_enable, set_pwm_enable, 0); 555static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO, 556 show_pwm_mode, set_pwm_mode, 0); 557static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, 558 show_pwm, set_pwm, 1); 559static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR, 560 show_pwm_enable, set_pwm_enable, 1); 561static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO, 562 show_pwm_mode, set_pwm_mode, 1); 563 564static struct attribute *f75375_attributes[] = { 565 &sensor_dev_attr_temp1_input.dev_attr.attr, 566 &sensor_dev_attr_temp1_max.dev_attr.attr, 567 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 568 &sensor_dev_attr_temp2_input.dev_attr.attr, 569 &sensor_dev_attr_temp2_max.dev_attr.attr, 570 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr, 571 &sensor_dev_attr_fan1_input.dev_attr.attr, 572 &sensor_dev_attr_fan1_full.dev_attr.attr, 573 &sensor_dev_attr_fan1_min.dev_attr.attr, 574 &sensor_dev_attr_fan1_exp.dev_attr.attr, 575 &sensor_dev_attr_fan2_input.dev_attr.attr, 576 &sensor_dev_attr_fan2_full.dev_attr.attr, 577 &sensor_dev_attr_fan2_min.dev_attr.attr, 578 &sensor_dev_attr_fan2_exp.dev_attr.attr, 579 &sensor_dev_attr_pwm1.dev_attr.attr, 580 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 581 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 582 &sensor_dev_attr_pwm2.dev_attr.attr, 583 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 584 &sensor_dev_attr_pwm2_mode.dev_attr.attr, 585 &sensor_dev_attr_in0_input.dev_attr.attr, 586 &sensor_dev_attr_in0_max.dev_attr.attr, 587 &sensor_dev_attr_in0_min.dev_attr.attr, 588 &sensor_dev_attr_in1_input.dev_attr.attr, 589 &sensor_dev_attr_in1_max.dev_attr.attr, 590 &sensor_dev_attr_in1_min.dev_attr.attr, 591 &sensor_dev_attr_in2_input.dev_attr.attr, 592 &sensor_dev_attr_in2_max.dev_attr.attr, 593 &sensor_dev_attr_in2_min.dev_attr.attr, 594 &sensor_dev_attr_in3_input.dev_attr.attr, 595 &sensor_dev_attr_in3_max.dev_attr.attr, 596 &sensor_dev_attr_in3_min.dev_attr.attr, 597 NULL 598}; 599 600static const struct attribute_group f75375_group = { 601 .attrs = f75375_attributes, 602}; 603 604static void f75375_init(struct i2c_client *client, struct f75375_data *data, 605 struct f75375s_platform_data *f75375s_pdata) 606{ 607 int nr; 608 set_pwm_enable_direct(client, 0, f75375s_pdata->pwm_enable[0]); 609 set_pwm_enable_direct(client, 1, f75375s_pdata->pwm_enable[1]); 610 for (nr = 0; nr < 2; nr++) { 611 data->pwm[nr] = SENSORS_LIMIT(f75375s_pdata->pwm[nr], 0, 255); 612 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr), 613 data->pwm[nr]); 614 } 615 616} 617 618static int f75375_probe(struct i2c_client *client, 619 const struct i2c_device_id *id) 620{ 621 struct f75375_data *data; 622 struct f75375s_platform_data *f75375s_pdata = client->dev.platform_data; 623 int err; 624 625 if (!i2c_check_functionality(client->adapter, 626 I2C_FUNC_SMBUS_BYTE_DATA)) 627 return -EIO; 628 if (!(data = kzalloc(sizeof(struct f75375_data), GFP_KERNEL))) 629 return -ENOMEM; 630 631 i2c_set_clientdata(client, data); 632 mutex_init(&data->update_lock); 633 data->kind = id->driver_data; 634 635 if ((err = sysfs_create_group(&client->dev.kobj, &f75375_group))) 636 goto exit_free; 637 638 if (data->kind == f75375) { 639 err = sysfs_chmod_file(&client->dev.kobj, 640 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 641 S_IRUGO | S_IWUSR); 642 if (err) 643 goto exit_remove; 644 err = sysfs_chmod_file(&client->dev.kobj, 645 &sensor_dev_attr_pwm2_mode.dev_attr.attr, 646 S_IRUGO | S_IWUSR); 647 if (err) 648 goto exit_remove; 649 } 650 651 data->hwmon_dev = hwmon_device_register(&client->dev); 652 if (IS_ERR(data->hwmon_dev)) { 653 err = PTR_ERR(data->hwmon_dev); 654 goto exit_remove; 655 } 656 657 if (f75375s_pdata != NULL) 658 f75375_init(client, data, f75375s_pdata); 659 660 return 0; 661 662exit_remove: 663 sysfs_remove_group(&client->dev.kobj, &f75375_group); 664exit_free: 665 kfree(data); 666 return err; 667} 668 669static int f75375_remove(struct i2c_client *client) 670{ 671 struct f75375_data *data = i2c_get_clientdata(client); 672 hwmon_device_unregister(data->hwmon_dev); 673 sysfs_remove_group(&client->dev.kobj, &f75375_group); 674 kfree(data); 675 return 0; 676} 677 678/* Return 0 if detection is successful, -ENODEV otherwise */ 679static int f75375_detect(struct i2c_client *client, 680 struct i2c_board_info *info) 681{ 682 struct i2c_adapter *adapter = client->adapter; 683 u16 vendid, chipid; 684 u8 version; 685 const char *name; 686 687 vendid = f75375_read16(client, F75375_REG_VENDOR); 688 chipid = f75375_read16(client, F75375_CHIP_ID); 689 if (chipid == 0x0306 && vendid == 0x1934) 690 name = "f75375"; 691 else if (chipid == 0x0204 && vendid == 0x1934) 692 name = "f75373"; 693 else 694 return -ENODEV; 695 696 version = f75375_read8(client, F75375_REG_VERSION); 697 dev_info(&adapter->dev, "found %s version: %02X\n", name, version); 698 strlcpy(info->type, name, I2C_NAME_SIZE); 699 700 return 0; 701} 702 703static int __init sensors_f75375_init(void) 704{ 705 return i2c_add_driver(&f75375_driver); 706} 707 708static void __exit sensors_f75375_exit(void) 709{ 710 i2c_del_driver(&f75375_driver); 711} 712 713MODULE_AUTHOR("Riku Voipio"); 714MODULE_LICENSE("GPL"); 715MODULE_DESCRIPTION("F75373/F75375 hardware monitoring driver"); 716 717module_init(sensors_f75375_init); 718module_exit(sensors_f75375_exit);