1/* 2 lm93.c - Part of lm_sensors, Linux kernel modules for hardware monitoring 3 4 Author/Maintainer: Mark M. Hoffman <mhoffman@lightlink.com> 5 Copyright (c) 2004 Utilitek Systems, Inc. 6 7 derived in part from lm78.c: 8 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 9 10 derived in part from lm85.c: 11 Copyright (c) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com> 12 Copyright (c) 2003 Margit Schubert-While <margitsw@t-online.de> 13 14 derived in part from w83l785ts.c: 15 Copyright (c) 2003-2004 Jean Delvare <khali@linux-fr.org> 16 17 Ported to Linux 2.6 by Eric J. Bowersox <ericb@aspsys.com> 18 Copyright (c) 2005 Aspen Systems, Inc. 19 20 Adapted to 2.6.20 by Carsten Emde <cbe@osadl.org> 21 Copyright (c) 2006 Carsten Emde, Open Source Automation Development Lab 22 23 Modified for mainline integration by Hans J. Koch <hjk@linutronix.de> 24 Copyright (c) 2007 Hans J. Koch, Linutronix GmbH 25 26 This program is free software; you can redistribute it and/or modify 27 it under the terms of the GNU General Public License as published by 28 the Free Software Foundation; either version 2 of the License, or 29 (at your option) any later version. 30 31 This program is distributed in the hope that it will be useful, 32 but WITHOUT ANY WARRANTY; without even the implied warranty of 33 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 34 GNU General Public License for more details. 35 36 You should have received a copy of the GNU General Public License 37 along with this program; if not, write to the Free Software 38 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 39*/ 40 41#include <linux/module.h> 42#include <linux/init.h> 43#include <linux/slab.h> 44#include <linux/i2c.h> 45#include <linux/hwmon.h> 46#include <linux/hwmon-sysfs.h> 47#include <linux/hwmon-vid.h> 48#include <linux/err.h> 49#include <linux/delay.h> 50 51/* LM93 REGISTER ADDRESSES */ 52 53/* miscellaneous */ 54#define LM93_REG_MFR_ID 0x3e 55#define LM93_REG_VER 0x3f 56#define LM93_REG_STATUS_CONTROL 0xe2 57#define LM93_REG_CONFIG 0xe3 58#define LM93_REG_SLEEP_CONTROL 0xe4 59 60/* alarm values start here */ 61#define LM93_REG_HOST_ERROR_1 0x48 62 63/* voltage inputs: in1-in16 (nr => 0-15) */ 64#define LM93_REG_IN(nr) (0x56 + (nr)) 65#define LM93_REG_IN_MIN(nr) (0x90 + (nr) * 2) 66#define LM93_REG_IN_MAX(nr) (0x91 + (nr) * 2) 67 68/* temperature inputs: temp1-temp4 (nr => 0-3) */ 69#define LM93_REG_TEMP(nr) (0x50 + (nr)) 70#define LM93_REG_TEMP_MIN(nr) (0x78 + (nr) * 2) 71#define LM93_REG_TEMP_MAX(nr) (0x79 + (nr) * 2) 72 73/* temp[1-4]_auto_boost (nr => 0-3) */ 74#define LM93_REG_BOOST(nr) (0x80 + (nr)) 75 76/* #PROCHOT inputs: prochot1-prochot2 (nr => 0-1) */ 77#define LM93_REG_PROCHOT_CUR(nr) (0x67 + (nr) * 2) 78#define LM93_REG_PROCHOT_AVG(nr) (0x68 + (nr) * 2) 79#define LM93_REG_PROCHOT_MAX(nr) (0xb0 + (nr)) 80 81/* fan tach inputs: fan1-fan4 (nr => 0-3) */ 82#define LM93_REG_FAN(nr) (0x6e + (nr) * 2) 83#define LM93_REG_FAN_MIN(nr) (0xb4 + (nr) * 2) 84 85/* pwm outputs: pwm1-pwm2 (nr => 0-1, reg => 0-3) */ 86#define LM93_REG_PWM_CTL(nr,reg) (0xc8 + (reg) + (nr) * 4) 87#define LM93_PWM_CTL1 0x0 88#define LM93_PWM_CTL2 0x1 89#define LM93_PWM_CTL3 0x2 90#define LM93_PWM_CTL4 0x3 91 92/* GPIO input state */ 93#define LM93_REG_GPI 0x6b 94 95/* vid inputs: vid1-vid2 (nr => 0-1) */ 96#define LM93_REG_VID(nr) (0x6c + (nr)) 97 98/* vccp1 & vccp2: VID relative inputs (nr => 0-1) */ 99#define LM93_REG_VCCP_LIMIT_OFF(nr) (0xb2 + (nr)) 100 101/* temp[1-4]_auto_boost_hyst */ 102#define LM93_REG_BOOST_HYST_12 0xc0 103#define LM93_REG_BOOST_HYST_34 0xc1 104#define LM93_REG_BOOST_HYST(nr) (0xc0 + (nr)/2) 105 106/* temp[1-4]_auto_pwm_[min|hyst] */ 107#define LM93_REG_PWM_MIN_HYST_12 0xc3 108#define LM93_REG_PWM_MIN_HYST_34 0xc4 109#define LM93_REG_PWM_MIN_HYST(nr) (0xc3 + (nr)/2) 110 111/* prochot_override & prochot_interval */ 112#define LM93_REG_PROCHOT_OVERRIDE 0xc6 113#define LM93_REG_PROCHOT_INTERVAL 0xc7 114 115/* temp[1-4]_auto_base (nr => 0-3) */ 116#define LM93_REG_TEMP_BASE(nr) (0xd0 + (nr)) 117 118/* temp[1-4]_auto_offsets (step => 0-11) */ 119#define LM93_REG_TEMP_OFFSET(step) (0xd4 + (step)) 120 121/* #PROCHOT & #VRDHOT PWM ramp control */ 122#define LM93_REG_PWM_RAMP_CTL 0xbf 123 124/* miscellaneous */ 125#define LM93_REG_SFC1 0xbc 126#define LM93_REG_SFC2 0xbd 127#define LM93_REG_GPI_VID_CTL 0xbe 128#define LM93_REG_SF_TACH_TO_PWM 0xe0 129 130/* error masks */ 131#define LM93_REG_GPI_ERR_MASK 0xec 132#define LM93_REG_MISC_ERR_MASK 0xed 133 134/* LM93 REGISTER VALUES */ 135#define LM93_MFR_ID 0x73 136#define LM93_MFR_ID_PROTOTYPE 0x72 137 138/* SMBus capabilities */ 139#define LM93_SMBUS_FUNC_FULL (I2C_FUNC_SMBUS_BYTE_DATA | \ 140 I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_DATA) 141#define LM93_SMBUS_FUNC_MIN (I2C_FUNC_SMBUS_BYTE_DATA | \ 142 I2C_FUNC_SMBUS_WORD_DATA) 143 144/* Addresses to scan */ 145static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 146 147/* Insmod parameters */ 148 149static int disable_block; 150module_param(disable_block, bool, 0); 151MODULE_PARM_DESC(disable_block, 152 "Set to non-zero to disable SMBus block data transactions."); 153 154static int init; 155module_param(init, bool, 0); 156MODULE_PARM_DESC(init, "Set to non-zero to force chip initialization."); 157 158static int vccp_limit_type[2] = {0,0}; 159module_param_array(vccp_limit_type, int, NULL, 0); 160MODULE_PARM_DESC(vccp_limit_type, "Configures in7 and in8 limit modes."); 161 162static int vid_agtl; 163module_param(vid_agtl, int, 0); 164MODULE_PARM_DESC(vid_agtl, "Configures VID pin input thresholds."); 165 166/* Driver data */ 167static struct i2c_driver lm93_driver; 168 169/* LM93 BLOCK READ COMMANDS */ 170static const struct { u8 cmd; u8 len; } lm93_block_read_cmds[12] = { 171 { 0xf2, 8 }, 172 { 0xf3, 8 }, 173 { 0xf4, 6 }, 174 { 0xf5, 16 }, 175 { 0xf6, 4 }, 176 { 0xf7, 8 }, 177 { 0xf8, 12 }, 178 { 0xf9, 32 }, 179 { 0xfa, 8 }, 180 { 0xfb, 8 }, 181 { 0xfc, 16 }, 182 { 0xfd, 9 }, 183}; 184 185/* ALARMS: SYSCTL format described further below 186 REG: 64 bits in 8 registers, as immediately below */ 187struct block1_t { 188 u8 host_status_1; 189 u8 host_status_2; 190 u8 host_status_3; 191 u8 host_status_4; 192 u8 p1_prochot_status; 193 u8 p2_prochot_status; 194 u8 gpi_status; 195 u8 fan_status; 196}; 197 198/* 199 * Client-specific data 200 */ 201struct lm93_data { 202 struct device *hwmon_dev; 203 204 struct mutex update_lock; 205 unsigned long last_updated; /* In jiffies */ 206 207 /* client update function */ 208 void (*update)(struct lm93_data *, struct i2c_client *); 209 210 char valid; /* !=0 if following fields are valid */ 211 212 /* register values, arranged by block read groups */ 213 struct block1_t block1; 214 215 /* temp1 - temp4: unfiltered readings 216 temp1 - temp2: filtered readings */ 217 u8 block2[6]; 218 219 /* vin1 - vin16: readings */ 220 u8 block3[16]; 221 222 /* prochot1 - prochot2: readings */ 223 struct { 224 u8 cur; 225 u8 avg; 226 } block4[2]; 227 228 /* fan counts 1-4 => 14-bits, LE, *left* justified */ 229 u16 block5[4]; 230 231 /* block6 has a lot of data we don't need */ 232 struct { 233 u8 min; 234 u8 max; 235 } temp_lim[4]; 236 237 /* vin1 - vin16: low and high limits */ 238 struct { 239 u8 min; 240 u8 max; 241 } block7[16]; 242 243 /* fan count limits 1-4 => same format as block5 */ 244 u16 block8[4]; 245 246 /* pwm control registers (2 pwms, 4 regs) */ 247 u8 block9[2][4]; 248 249 /* auto/pwm base temp and offset temp registers */ 250 struct { 251 u8 base[4]; 252 u8 offset[12]; 253 } block10; 254 255 /* master config register */ 256 u8 config; 257 258 /* VID1 & VID2 => register format, 6-bits, right justified */ 259 u8 vid[2]; 260 261 /* prochot1 - prochot2: limits */ 262 u8 prochot_max[2]; 263 264 /* vccp1 & vccp2 (in7 & in8): VID relative limits (register format) */ 265 u8 vccp_limits[2]; 266 267 /* GPIO input state (register format, i.e. inverted) */ 268 u8 gpi; 269 270 /* #PROCHOT override (register format) */ 271 u8 prochot_override; 272 273 /* #PROCHOT intervals (register format) */ 274 u8 prochot_interval; 275 276 /* Fan Boost Temperatures (register format) */ 277 u8 boost[4]; 278 279 /* Fan Boost Hysteresis (register format) */ 280 u8 boost_hyst[2]; 281 282 /* Temperature Zone Min. PWM & Hysteresis (register format) */ 283 u8 auto_pwm_min_hyst[2]; 284 285 /* #PROCHOT & #VRDHOT PWM Ramp Control */ 286 u8 pwm_ramp_ctl; 287 288 /* miscellaneous setup regs */ 289 u8 sfc1; 290 u8 sfc2; 291 u8 sf_tach_to_pwm; 292 293 /* The two PWM CTL2 registers can read something other than what was 294 last written for the OVR_DC field (duty cycle override). So, we 295 save the user-commanded value here. */ 296 u8 pwm_override[2]; 297}; 298 299/* VID: mV 300 REG: 6-bits, right justified, *always* using Intel VRM/VRD 10 */ 301static int LM93_VID_FROM_REG(u8 reg) 302{ 303 return vid_from_reg((reg & 0x3f), 100); 304} 305 306/* min, max, and nominal register values, per channel (u8) */ 307static const u8 lm93_vin_reg_min[16] = { 308 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 309 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae, 310}; 311static const u8 lm93_vin_reg_max[16] = { 312 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 313 0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1, 314}; 315/* Values from the datasheet. They're here for documentation only. 316static const u8 lm93_vin_reg_nom[16] = { 317 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 318 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x40, 0xc0, 319}; 320*/ 321 322/* min, max, and nominal voltage readings, per channel (mV)*/ 323static const unsigned long lm93_vin_val_min[16] = { 324 0, 0, 0, 0, 0, 0, 0, 0, 325 0, 0, 0, 0, 0, 0, 0, 3000, 326}; 327 328static const unsigned long lm93_vin_val_max[16] = { 329 1236, 1236, 1236, 1600, 2000, 2000, 1600, 1600, 330 4400, 6500, 3333, 2625, 1312, 1312, 1236, 3600, 331}; 332/* Values from the datasheet. They're here for documentation only. 333static const unsigned long lm93_vin_val_nom[16] = { 334 927, 927, 927, 1200, 1500, 1500, 1200, 1200, 335 3300, 5000, 2500, 1969, 984, 984, 309, 3300, 336}; 337*/ 338 339static unsigned LM93_IN_FROM_REG(int nr, u8 reg) 340{ 341 const long uV_max = lm93_vin_val_max[nr] * 1000; 342 const long uV_min = lm93_vin_val_min[nr] * 1000; 343 344 const long slope = (uV_max - uV_min) / 345 (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]); 346 const long intercept = uV_min - slope * lm93_vin_reg_min[nr]; 347 348 return (slope * reg + intercept + 500) / 1000; 349} 350 351/* IN: mV, limits determined by channel nr 352 REG: scaling determined by channel nr */ 353static u8 LM93_IN_TO_REG(int nr, unsigned val) 354{ 355 /* range limit */ 356 const long mV = SENSORS_LIMIT(val, 357 lm93_vin_val_min[nr], lm93_vin_val_max[nr]); 358 359 /* try not to lose too much precision here */ 360 const long uV = mV * 1000; 361 const long uV_max = lm93_vin_val_max[nr] * 1000; 362 const long uV_min = lm93_vin_val_min[nr] * 1000; 363 364 /* convert */ 365 const long slope = (uV_max - uV_min) / 366 (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]); 367 const long intercept = uV_min - slope * lm93_vin_reg_min[nr]; 368 369 u8 result = ((uV - intercept + (slope/2)) / slope); 370 result = SENSORS_LIMIT(result, 371 lm93_vin_reg_min[nr], lm93_vin_reg_max[nr]); 372 return result; 373} 374 375/* vid in mV, upper == 0 indicates low limit, otherwise upper limit */ 376static unsigned LM93_IN_REL_FROM_REG(u8 reg, int upper, int vid) 377{ 378 const long uV_offset = upper ? (((reg >> 4 & 0x0f) + 1) * 12500) : 379 (((reg >> 0 & 0x0f) + 1) * -25000); 380 const long uV_vid = vid * 1000; 381 return (uV_vid + uV_offset + 5000) / 10000; 382} 383 384#define LM93_IN_MIN_FROM_REG(reg,vid) LM93_IN_REL_FROM_REG(reg,0,vid) 385#define LM93_IN_MAX_FROM_REG(reg,vid) LM93_IN_REL_FROM_REG(reg,1,vid) 386 387/* vid in mV , upper == 0 indicates low limit, otherwise upper limit 388 upper also determines which nibble of the register is returned 389 (the other nibble will be 0x0) */ 390static u8 LM93_IN_REL_TO_REG(unsigned val, int upper, int vid) 391{ 392 long uV_offset = vid * 1000 - val * 10000; 393 if (upper) { 394 uV_offset = SENSORS_LIMIT(uV_offset, 12500, 200000); 395 return (u8)((uV_offset / 12500 - 1) << 4); 396 } else { 397 uV_offset = SENSORS_LIMIT(uV_offset, -400000, -25000); 398 return (u8)((uV_offset / -25000 - 1) << 0); 399 } 400} 401 402/* TEMP: 1/1000 degrees C (-128C to +127C) 403 REG: 1C/bit, two's complement */ 404static int LM93_TEMP_FROM_REG(u8 reg) 405{ 406 return (s8)reg * 1000; 407} 408 409#define LM93_TEMP_MIN (-128000) 410#define LM93_TEMP_MAX ( 127000) 411 412/* TEMP: 1/1000 degrees C (-128C to +127C) 413 REG: 1C/bit, two's complement */ 414static u8 LM93_TEMP_TO_REG(long temp) 415{ 416 int ntemp = SENSORS_LIMIT(temp, LM93_TEMP_MIN, LM93_TEMP_MAX); 417 ntemp += (ntemp<0 ? -500 : 500); 418 return (u8)(ntemp / 1000); 419} 420 421/* Determine 4-bit temperature offset resolution */ 422static int LM93_TEMP_OFFSET_MODE_FROM_REG(u8 sfc2, int nr) 423{ 424 /* mode: 0 => 1C/bit, nonzero => 0.5C/bit */ 425 return sfc2 & (nr < 2 ? 0x10 : 0x20); 426} 427 428/* This function is common to all 4-bit temperature offsets 429 reg is 4 bits right justified 430 mode 0 => 1C/bit, mode !0 => 0.5C/bit */ 431static int LM93_TEMP_OFFSET_FROM_REG(u8 reg, int mode) 432{ 433 return (reg & 0x0f) * (mode ? 5 : 10); 434} 435 436#define LM93_TEMP_OFFSET_MIN ( 0) 437#define LM93_TEMP_OFFSET_MAX0 (150) 438#define LM93_TEMP_OFFSET_MAX1 ( 75) 439 440/* This function is common to all 4-bit temperature offsets 441 returns 4 bits right justified 442 mode 0 => 1C/bit, mode !0 => 0.5C/bit */ 443static u8 LM93_TEMP_OFFSET_TO_REG(int off, int mode) 444{ 445 int factor = mode ? 5 : 10; 446 447 off = SENSORS_LIMIT(off, LM93_TEMP_OFFSET_MIN, 448 mode ? LM93_TEMP_OFFSET_MAX1 : LM93_TEMP_OFFSET_MAX0); 449 return (u8)((off + factor/2) / factor); 450} 451 452/* 0 <= nr <= 3 */ 453static int LM93_TEMP_AUTO_OFFSET_FROM_REG(u8 reg, int nr, int mode) 454{ 455 /* temp1-temp2 (nr=0,1) use lower nibble */ 456 if (nr < 2) 457 return LM93_TEMP_OFFSET_FROM_REG(reg & 0x0f, mode); 458 459 /* temp3-temp4 (nr=2,3) use upper nibble */ 460 else 461 return LM93_TEMP_OFFSET_FROM_REG(reg >> 4 & 0x0f, mode); 462} 463 464/* TEMP: 1/10 degrees C (0C to +15C (mode 0) or +7.5C (mode non-zero)) 465 REG: 1.0C/bit (mode 0) or 0.5C/bit (mode non-zero) 466 0 <= nr <= 3 */ 467static u8 LM93_TEMP_AUTO_OFFSET_TO_REG(u8 old, int off, int nr, int mode) 468{ 469 u8 new = LM93_TEMP_OFFSET_TO_REG(off, mode); 470 471 /* temp1-temp2 (nr=0,1) use lower nibble */ 472 if (nr < 2) 473 return (old & 0xf0) | (new & 0x0f); 474 475 /* temp3-temp4 (nr=2,3) use upper nibble */ 476 else 477 return (new << 4 & 0xf0) | (old & 0x0f); 478} 479 480static int LM93_AUTO_BOOST_HYST_FROM_REGS(struct lm93_data *data, int nr, 481 int mode) 482{ 483 u8 reg; 484 485 switch (nr) { 486 case 0: 487 reg = data->boost_hyst[0] & 0x0f; 488 break; 489 case 1: 490 reg = data->boost_hyst[0] >> 4 & 0x0f; 491 break; 492 case 2: 493 reg = data->boost_hyst[1] & 0x0f; 494 break; 495 case 3: 496 default: 497 reg = data->boost_hyst[1] >> 4 & 0x0f; 498 break; 499 } 500 501 return LM93_TEMP_FROM_REG(data->boost[nr]) - 502 LM93_TEMP_OFFSET_FROM_REG(reg, mode); 503} 504 505static u8 LM93_AUTO_BOOST_HYST_TO_REG(struct lm93_data *data, long hyst, 506 int nr, int mode) 507{ 508 u8 reg = LM93_TEMP_OFFSET_TO_REG( 509 (LM93_TEMP_FROM_REG(data->boost[nr]) - hyst), mode); 510 511 switch (nr) { 512 case 0: 513 reg = (data->boost_hyst[0] & 0xf0) | (reg & 0x0f); 514 break; 515 case 1: 516 reg = (reg << 4 & 0xf0) | (data->boost_hyst[0] & 0x0f); 517 break; 518 case 2: 519 reg = (data->boost_hyst[1] & 0xf0) | (reg & 0x0f); 520 break; 521 case 3: 522 default: 523 reg = (reg << 4 & 0xf0) | (data->boost_hyst[1] & 0x0f); 524 break; 525 } 526 527 return reg; 528} 529 530/* PWM: 0-255 per sensors documentation 531 REG: 0-13 as mapped below... right justified */ 532typedef enum { LM93_PWM_MAP_HI_FREQ, LM93_PWM_MAP_LO_FREQ } pwm_freq_t; 533static int lm93_pwm_map[2][16] = { 534 { 535 0x00, /* 0.00% */ 0x40, /* 25.00% */ 536 0x50, /* 31.25% */ 0x60, /* 37.50% */ 537 0x70, /* 43.75% */ 0x80, /* 50.00% */ 538 0x90, /* 56.25% */ 0xa0, /* 62.50% */ 539 0xb0, /* 68.75% */ 0xc0, /* 75.00% */ 540 0xd0, /* 81.25% */ 0xe0, /* 87.50% */ 541 0xf0, /* 93.75% */ 0xff, /* 100.00% */ 542 0xff, 0xff, /* 14, 15 are reserved and should never occur */ 543 }, 544 { 545 0x00, /* 0.00% */ 0x40, /* 25.00% */ 546 0x49, /* 28.57% */ 0x52, /* 32.14% */ 547 0x5b, /* 35.71% */ 0x64, /* 39.29% */ 548 0x6d, /* 42.86% */ 0x76, /* 46.43% */ 549 0x80, /* 50.00% */ 0x89, /* 53.57% */ 550 0x92, /* 57.14% */ 0xb6, /* 71.43% */ 551 0xdb, /* 85.71% */ 0xff, /* 100.00% */ 552 0xff, 0xff, /* 14, 15 are reserved and should never occur */ 553 }, 554}; 555 556static int LM93_PWM_FROM_REG(u8 reg, pwm_freq_t freq) 557{ 558 return lm93_pwm_map[freq][reg & 0x0f]; 559} 560 561/* round up to nearest match */ 562static u8 LM93_PWM_TO_REG(int pwm, pwm_freq_t freq) 563{ 564 int i; 565 for (i = 0; i < 13; i++) 566 if (pwm <= lm93_pwm_map[freq][i]) 567 break; 568 569 /* can fall through with i==13 */ 570 return (u8)i; 571} 572 573static int LM93_FAN_FROM_REG(u16 regs) 574{ 575 const u16 count = le16_to_cpu(regs) >> 2; 576 return count==0 ? -1 : count==0x3fff ? 0: 1350000 / count; 577} 578 579/* 580 * RPM: (82.5 to 1350000) 581 * REG: 14-bits, LE, *left* justified 582 */ 583static u16 LM93_FAN_TO_REG(long rpm) 584{ 585 u16 count, regs; 586 587 if (rpm == 0) { 588 count = 0x3fff; 589 } else { 590 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 591 count = SENSORS_LIMIT((1350000 + rpm) / rpm, 1, 0x3ffe); 592 } 593 594 regs = count << 2; 595 return cpu_to_le16(regs); 596} 597 598/* PWM FREQ: HZ 599 REG: 0-7 as mapped below */ 600static int lm93_pwm_freq_map[8] = { 601 22500, 96, 84, 72, 60, 48, 36, 12 602}; 603 604static int LM93_PWM_FREQ_FROM_REG(u8 reg) 605{ 606 return lm93_pwm_freq_map[reg & 0x07]; 607} 608 609/* round up to nearest match */ 610static u8 LM93_PWM_FREQ_TO_REG(int freq) 611{ 612 int i; 613 for (i = 7; i > 0; i--) 614 if (freq <= lm93_pwm_freq_map[i]) 615 break; 616 617 /* can fall through with i==0 */ 618 return (u8)i; 619} 620 621/* TIME: 1/100 seconds 622 * REG: 0-7 as mapped below */ 623static int lm93_spinup_time_map[8] = { 624 0, 10, 25, 40, 70, 100, 200, 400, 625}; 626 627static int LM93_SPINUP_TIME_FROM_REG(u8 reg) 628{ 629 return lm93_spinup_time_map[reg >> 5 & 0x07]; 630} 631 632/* round up to nearest match */ 633static u8 LM93_SPINUP_TIME_TO_REG(int time) 634{ 635 int i; 636 for (i = 0; i < 7; i++) 637 if (time <= lm93_spinup_time_map[i]) 638 break; 639 640 /* can fall through with i==8 */ 641 return (u8)i; 642} 643 644#define LM93_RAMP_MIN 0 645#define LM93_RAMP_MAX 75 646 647static int LM93_RAMP_FROM_REG(u8 reg) 648{ 649 return (reg & 0x0f) * 5; 650} 651 652/* RAMP: 1/100 seconds 653 REG: 50mS/bit 4-bits right justified */ 654static u8 LM93_RAMP_TO_REG(int ramp) 655{ 656 ramp = SENSORS_LIMIT(ramp, LM93_RAMP_MIN, LM93_RAMP_MAX); 657 return (u8)((ramp + 2) / 5); 658} 659 660/* PROCHOT: 0-255, 0 => 0%, 255 => > 96.6% 661 * REG: (same) */ 662static u8 LM93_PROCHOT_TO_REG(long prochot) 663{ 664 prochot = SENSORS_LIMIT(prochot, 0, 255); 665 return (u8)prochot; 666} 667 668/* PROCHOT-INTERVAL: 73 - 37200 (1/100 seconds) 669 * REG: 0-9 as mapped below */ 670static int lm93_interval_map[10] = { 671 73, 146, 290, 580, 1170, 2330, 4660, 9320, 18600, 37200, 672}; 673 674static int LM93_INTERVAL_FROM_REG(u8 reg) 675{ 676 return lm93_interval_map[reg & 0x0f]; 677} 678 679/* round up to nearest match */ 680static u8 LM93_INTERVAL_TO_REG(long interval) 681{ 682 int i; 683 for (i = 0; i < 9; i++) 684 if (interval <= lm93_interval_map[i]) 685 break; 686 687 /* can fall through with i==9 */ 688 return (u8)i; 689} 690 691/* GPIO: 0-255, GPIO0 is LSB 692 * REG: inverted */ 693static unsigned LM93_GPI_FROM_REG(u8 reg) 694{ 695 return ~reg & 0xff; 696} 697 698/* alarm bitmask definitions 699 The LM93 has nearly 64 bits of error status... I've pared that down to 700 what I think is a useful subset in order to fit it into 32 bits. 701 702 Especially note that the #VRD_HOT alarms are missing because we provide 703 that information as values in another sysfs file. 704 705 If libsensors is extended to support 64 bit values, this could be revisited. 706*/ 707#define LM93_ALARM_IN1 0x00000001 708#define LM93_ALARM_IN2 0x00000002 709#define LM93_ALARM_IN3 0x00000004 710#define LM93_ALARM_IN4 0x00000008 711#define LM93_ALARM_IN5 0x00000010 712#define LM93_ALARM_IN6 0x00000020 713#define LM93_ALARM_IN7 0x00000040 714#define LM93_ALARM_IN8 0x00000080 715#define LM93_ALARM_IN9 0x00000100 716#define LM93_ALARM_IN10 0x00000200 717#define LM93_ALARM_IN11 0x00000400 718#define LM93_ALARM_IN12 0x00000800 719#define LM93_ALARM_IN13 0x00001000 720#define LM93_ALARM_IN14 0x00002000 721#define LM93_ALARM_IN15 0x00004000 722#define LM93_ALARM_IN16 0x00008000 723#define LM93_ALARM_FAN1 0x00010000 724#define LM93_ALARM_FAN2 0x00020000 725#define LM93_ALARM_FAN3 0x00040000 726#define LM93_ALARM_FAN4 0x00080000 727#define LM93_ALARM_PH1_ERR 0x00100000 728#define LM93_ALARM_PH2_ERR 0x00200000 729#define LM93_ALARM_SCSI1_ERR 0x00400000 730#define LM93_ALARM_SCSI2_ERR 0x00800000 731#define LM93_ALARM_DVDDP1_ERR 0x01000000 732#define LM93_ALARM_DVDDP2_ERR 0x02000000 733#define LM93_ALARM_D1_ERR 0x04000000 734#define LM93_ALARM_D2_ERR 0x08000000 735#define LM93_ALARM_TEMP1 0x10000000 736#define LM93_ALARM_TEMP2 0x20000000 737#define LM93_ALARM_TEMP3 0x40000000 738 739static unsigned LM93_ALARMS_FROM_REG(struct block1_t b1) 740{ 741 unsigned result; 742 result = b1.host_status_2 & 0x3f; 743 744 if (vccp_limit_type[0]) 745 result |= (b1.host_status_4 & 0x10) << 2; 746 else 747 result |= b1.host_status_2 & 0x40; 748 749 if (vccp_limit_type[1]) 750 result |= (b1.host_status_4 & 0x20) << 2; 751 else 752 result |= b1.host_status_2 & 0x80; 753 754 result |= b1.host_status_3 << 8; 755 result |= (b1.fan_status & 0x0f) << 16; 756 result |= (b1.p1_prochot_status & 0x80) << 13; 757 result |= (b1.p2_prochot_status & 0x80) << 14; 758 result |= (b1.host_status_4 & 0xfc) << 20; 759 result |= (b1.host_status_1 & 0x07) << 28; 760 return result; 761} 762 763#define MAX_RETRIES 5 764 765static u8 lm93_read_byte(struct i2c_client *client, u8 reg) 766{ 767 int value, i; 768 769 /* retry in case of read errors */ 770 for (i=1; i<=MAX_RETRIES; i++) { 771 if ((value = i2c_smbus_read_byte_data(client, reg)) >= 0) { 772 return value; 773 } else { 774 dev_warn(&client->dev,"lm93: read byte data failed, " 775 "address 0x%02x.\n", reg); 776 mdelay(i + 3); 777 } 778 779 } 780 781 /* <TODO> what to return in case of error? */ 782 dev_err(&client->dev,"lm93: All read byte retries failed!!\n"); 783 return 0; 784} 785 786static int lm93_write_byte(struct i2c_client *client, u8 reg, u8 value) 787{ 788 int result; 789 790 /* <TODO> how to handle write errors? */ 791 result = i2c_smbus_write_byte_data(client, reg, value); 792 793 if (result < 0) 794 dev_warn(&client->dev,"lm93: write byte data failed, " 795 "0x%02x at address 0x%02x.\n", value, reg); 796 797 return result; 798} 799 800static u16 lm93_read_word(struct i2c_client *client, u8 reg) 801{ 802 int value, i; 803 804 /* retry in case of read errors */ 805 for (i=1; i<=MAX_RETRIES; i++) { 806 if ((value = i2c_smbus_read_word_data(client, reg)) >= 0) { 807 return value; 808 } else { 809 dev_warn(&client->dev,"lm93: read word data failed, " 810 "address 0x%02x.\n", reg); 811 mdelay(i + 3); 812 } 813 814 } 815 816 /* <TODO> what to return in case of error? */ 817 dev_err(&client->dev,"lm93: All read word retries failed!!\n"); 818 return 0; 819} 820 821static int lm93_write_word(struct i2c_client *client, u8 reg, u16 value) 822{ 823 int result; 824 825 /* <TODO> how to handle write errors? */ 826 result = i2c_smbus_write_word_data(client, reg, value); 827 828 if (result < 0) 829 dev_warn(&client->dev,"lm93: write word data failed, " 830 "0x%04x at address 0x%02x.\n", value, reg); 831 832 return result; 833} 834 835static u8 lm93_block_buffer[I2C_SMBUS_BLOCK_MAX]; 836 837/* 838 read block data into values, retry if not expected length 839 fbn => index to lm93_block_read_cmds table 840 (Fixed Block Number - section 14.5.2 of LM93 datasheet) 841*/ 842static void lm93_read_block(struct i2c_client *client, u8 fbn, u8 *values) 843{ 844 int i, result=0; 845 846 for (i = 1; i <= MAX_RETRIES; i++) { 847 result = i2c_smbus_read_block_data(client, 848 lm93_block_read_cmds[fbn].cmd, lm93_block_buffer); 849 850 if (result == lm93_block_read_cmds[fbn].len) { 851 break; 852 } else { 853 dev_warn(&client->dev,"lm93: block read data failed, " 854 "command 0x%02x.\n", 855 lm93_block_read_cmds[fbn].cmd); 856 mdelay(i + 3); 857 } 858 } 859 860 if (result == lm93_block_read_cmds[fbn].len) { 861 memcpy(values,lm93_block_buffer,lm93_block_read_cmds[fbn].len); 862 } else { 863 /* <TODO> what to do in case of error? */ 864 } 865} 866 867static struct lm93_data *lm93_update_device(struct device *dev) 868{ 869 struct i2c_client *client = to_i2c_client(dev); 870 struct lm93_data *data = i2c_get_clientdata(client); 871 const unsigned long interval = HZ + (HZ / 2); 872 873 mutex_lock(&data->update_lock); 874 875 if (time_after(jiffies, data->last_updated + interval) || 876 !data->valid) { 877 878 data->update(data, client); 879 data->last_updated = jiffies; 880 data->valid = 1; 881 } 882 883 mutex_unlock(&data->update_lock); 884 return data; 885} 886 887/* update routine for data that has no corresponding SMBus block command */ 888static void lm93_update_client_common(struct lm93_data *data, 889 struct i2c_client *client) 890{ 891 int i; 892 u8 *ptr; 893 894 /* temp1 - temp4: limits */ 895 for (i = 0; i < 4; i++) { 896 data->temp_lim[i].min = 897 lm93_read_byte(client, LM93_REG_TEMP_MIN(i)); 898 data->temp_lim[i].max = 899 lm93_read_byte(client, LM93_REG_TEMP_MAX(i)); 900 } 901 902 /* config register */ 903 data->config = lm93_read_byte(client, LM93_REG_CONFIG); 904 905 /* vid1 - vid2: values */ 906 for (i = 0; i < 2; i++) 907 data->vid[i] = lm93_read_byte(client, LM93_REG_VID(i)); 908 909 /* prochot1 - prochot2: limits */ 910 for (i = 0; i < 2; i++) 911 data->prochot_max[i] = lm93_read_byte(client, 912 LM93_REG_PROCHOT_MAX(i)); 913 914 /* vccp1 - vccp2: VID relative limits */ 915 for (i = 0; i < 2; i++) 916 data->vccp_limits[i] = lm93_read_byte(client, 917 LM93_REG_VCCP_LIMIT_OFF(i)); 918 919 /* GPIO input state */ 920 data->gpi = lm93_read_byte(client, LM93_REG_GPI); 921 922 /* #PROCHOT override state */ 923 data->prochot_override = lm93_read_byte(client, 924 LM93_REG_PROCHOT_OVERRIDE); 925 926 /* #PROCHOT intervals */ 927 data->prochot_interval = lm93_read_byte(client, 928 LM93_REG_PROCHOT_INTERVAL); 929 930 /* Fan Boost Temperature registers */ 931 for (i = 0; i < 4; i++) 932 data->boost[i] = lm93_read_byte(client, LM93_REG_BOOST(i)); 933 934 /* Fan Boost Temperature Hyst. registers */ 935 data->boost_hyst[0] = lm93_read_byte(client, LM93_REG_BOOST_HYST_12); 936 data->boost_hyst[1] = lm93_read_byte(client, LM93_REG_BOOST_HYST_34); 937 938 /* Temperature Zone Min. PWM & Hysteresis registers */ 939 data->auto_pwm_min_hyst[0] = 940 lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_12); 941 data->auto_pwm_min_hyst[1] = 942 lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_34); 943 944 /* #PROCHOT & #VRDHOT PWM Ramp Control register */ 945 data->pwm_ramp_ctl = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL); 946 947 /* misc setup registers */ 948 data->sfc1 = lm93_read_byte(client, LM93_REG_SFC1); 949 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2); 950 data->sf_tach_to_pwm = lm93_read_byte(client, 951 LM93_REG_SF_TACH_TO_PWM); 952 953 /* write back alarm values to clear */ 954 for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++) 955 lm93_write_byte(client, LM93_REG_HOST_ERROR_1 + i, *(ptr + i)); 956} 957 958/* update routine which uses SMBus block data commands */ 959static void lm93_update_client_full(struct lm93_data *data, 960 struct i2c_client *client) 961{ 962 dev_dbg(&client->dev,"starting device update (block data enabled)\n"); 963 964 /* in1 - in16: values & limits */ 965 lm93_read_block(client, 3, (u8 *)(data->block3)); 966 lm93_read_block(client, 7, (u8 *)(data->block7)); 967 968 /* temp1 - temp4: values */ 969 lm93_read_block(client, 2, (u8 *)(data->block2)); 970 971 /* prochot1 - prochot2: values */ 972 lm93_read_block(client, 4, (u8 *)(data->block4)); 973 974 /* fan1 - fan4: values & limits */ 975 lm93_read_block(client, 5, (u8 *)(data->block5)); 976 lm93_read_block(client, 8, (u8 *)(data->block8)); 977 978 /* pmw control registers */ 979 lm93_read_block(client, 9, (u8 *)(data->block9)); 980 981 /* alarm values */ 982 lm93_read_block(client, 1, (u8 *)(&data->block1)); 983 984 /* auto/pwm registers */ 985 lm93_read_block(client, 10, (u8 *)(&data->block10)); 986 987 lm93_update_client_common(data, client); 988} 989 990/* update routine which uses SMBus byte/word data commands only */ 991static void lm93_update_client_min(struct lm93_data *data, 992 struct i2c_client *client) 993{ 994 int i,j; 995 u8 *ptr; 996 997 dev_dbg(&client->dev,"starting device update (block data disabled)\n"); 998 999 /* in1 - in16: values & limits */ 1000 for (i = 0; i < 16; i++) { 1001 data->block3[i] = 1002 lm93_read_byte(client, LM93_REG_IN(i)); 1003 data->block7[i].min = 1004 lm93_read_byte(client, LM93_REG_IN_MIN(i)); 1005 data->block7[i].max = 1006 lm93_read_byte(client, LM93_REG_IN_MAX(i)); 1007 } 1008 1009 /* temp1 - temp4: values */ 1010 for (i = 0; i < 4; i++) { 1011 data->block2[i] = 1012 lm93_read_byte(client, LM93_REG_TEMP(i)); 1013 } 1014 1015 /* prochot1 - prochot2: values */ 1016 for (i = 0; i < 2; i++) { 1017 data->block4[i].cur = 1018 lm93_read_byte(client, LM93_REG_PROCHOT_CUR(i)); 1019 data->block4[i].avg = 1020 lm93_read_byte(client, LM93_REG_PROCHOT_AVG(i)); 1021 } 1022 1023 /* fan1 - fan4: values & limits */ 1024 for (i = 0; i < 4; i++) { 1025 data->block5[i] = 1026 lm93_read_word(client, LM93_REG_FAN(i)); 1027 data->block8[i] = 1028 lm93_read_word(client, LM93_REG_FAN_MIN(i)); 1029 } 1030 1031 /* pwm control registers */ 1032 for (i = 0; i < 2; i++) { 1033 for (j = 0; j < 4; j++) { 1034 data->block9[i][j] = 1035 lm93_read_byte(client, LM93_REG_PWM_CTL(i,j)); 1036 } 1037 } 1038 1039 /* alarm values */ 1040 for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++) { 1041 *(ptr + i) = 1042 lm93_read_byte(client, LM93_REG_HOST_ERROR_1 + i); 1043 } 1044 1045 /* auto/pwm (base temp) registers */ 1046 for (i = 0; i < 4; i++) { 1047 data->block10.base[i] = 1048 lm93_read_byte(client, LM93_REG_TEMP_BASE(i)); 1049 } 1050 1051 /* auto/pwm (offset temp) registers */ 1052 for (i = 0; i < 12; i++) { 1053 data->block10.offset[i] = 1054 lm93_read_byte(client, LM93_REG_TEMP_OFFSET(i)); 1055 } 1056 1057 lm93_update_client_common(data, client); 1058} 1059 1060/* following are the sysfs callback functions */ 1061static ssize_t show_in(struct device *dev, struct device_attribute *attr, 1062 char *buf) 1063{ 1064 int nr = (to_sensor_dev_attr(attr))->index; 1065 1066 struct lm93_data *data = lm93_update_device(dev); 1067 return sprintf(buf, "%d\n", LM93_IN_FROM_REG(nr, data->block3[nr])); 1068} 1069 1070static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 0); 1071static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 1); 1072static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 2); 1073static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 3); 1074static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 4); 1075static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 5); 1076static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 6); 1077static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 7); 1078static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_in, NULL, 8); 1079static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_in, NULL, 9); 1080static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_in, NULL, 10); 1081static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_in, NULL, 11); 1082static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_in, NULL, 12); 1083static SENSOR_DEVICE_ATTR(in14_input, S_IRUGO, show_in, NULL, 13); 1084static SENSOR_DEVICE_ATTR(in15_input, S_IRUGO, show_in, NULL, 14); 1085static SENSOR_DEVICE_ATTR(in16_input, S_IRUGO, show_in, NULL, 15); 1086 1087static ssize_t show_in_min(struct device *dev, 1088 struct device_attribute *attr, char *buf) 1089{ 1090 int nr = (to_sensor_dev_attr(attr))->index; 1091 struct lm93_data *data = lm93_update_device(dev); 1092 int vccp = nr - 6; 1093 long rc, vid; 1094 1095 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) { 1096 vid = LM93_VID_FROM_REG(data->vid[vccp]); 1097 rc = LM93_IN_MIN_FROM_REG(data->vccp_limits[vccp], vid); 1098 } 1099 else { 1100 rc = LM93_IN_FROM_REG(nr, data->block7[nr].min); \ 1101 } 1102 return sprintf(buf, "%ld\n", rc); \ 1103} 1104 1105static ssize_t store_in_min(struct device *dev, struct device_attribute *attr, 1106 const char *buf, size_t count) 1107{ 1108 int nr = (to_sensor_dev_attr(attr))->index; 1109 struct i2c_client *client = to_i2c_client(dev); 1110 struct lm93_data *data = i2c_get_clientdata(client); 1111 u32 val = simple_strtoul(buf, NULL, 10); 1112 int vccp = nr - 6; 1113 long vid; 1114 1115 mutex_lock(&data->update_lock); 1116 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) { 1117 vid = LM93_VID_FROM_REG(data->vid[vccp]); 1118 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0xf0) | 1119 LM93_IN_REL_TO_REG(val, 0, vid); 1120 lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp), 1121 data->vccp_limits[vccp]); 1122 } 1123 else { 1124 data->block7[nr].min = LM93_IN_TO_REG(nr,val); 1125 lm93_write_byte(client, LM93_REG_IN_MIN(nr), 1126 data->block7[nr].min); 1127 } 1128 mutex_unlock(&data->update_lock); 1129 return count; 1130} 1131 1132static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, 1133 show_in_min, store_in_min, 0); 1134static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, 1135 show_in_min, store_in_min, 1); 1136static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO, 1137 show_in_min, store_in_min, 2); 1138static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO, 1139 show_in_min, store_in_min, 3); 1140static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO, 1141 show_in_min, store_in_min, 4); 1142static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO, 1143 show_in_min, store_in_min, 5); 1144static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO, 1145 show_in_min, store_in_min, 6); 1146static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO, 1147 show_in_min, store_in_min, 7); 1148static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO, 1149 show_in_min, store_in_min, 8); 1150static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO, 1151 show_in_min, store_in_min, 9); 1152static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO, 1153 show_in_min, store_in_min, 10); 1154static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO, 1155 show_in_min, store_in_min, 11); 1156static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO, 1157 show_in_min, store_in_min, 12); 1158static SENSOR_DEVICE_ATTR(in14_min, S_IWUSR | S_IRUGO, 1159 show_in_min, store_in_min, 13); 1160static SENSOR_DEVICE_ATTR(in15_min, S_IWUSR | S_IRUGO, 1161 show_in_min, store_in_min, 14); 1162static SENSOR_DEVICE_ATTR(in16_min, S_IWUSR | S_IRUGO, 1163 show_in_min, store_in_min, 15); 1164 1165static ssize_t show_in_max(struct device *dev, 1166 struct device_attribute *attr, char *buf) 1167{ 1168 int nr = (to_sensor_dev_attr(attr))->index; 1169 struct lm93_data *data = lm93_update_device(dev); 1170 int vccp = nr - 6; 1171 long rc, vid; 1172 1173 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) { 1174 vid = LM93_VID_FROM_REG(data->vid[vccp]); 1175 rc = LM93_IN_MAX_FROM_REG(data->vccp_limits[vccp],vid); 1176 } 1177 else { 1178 rc = LM93_IN_FROM_REG(nr,data->block7[nr].max); \ 1179 } 1180 return sprintf(buf,"%ld\n",rc); \ 1181} 1182 1183static ssize_t store_in_max(struct device *dev, struct device_attribute *attr, 1184 const char *buf, size_t count) 1185{ 1186 int nr = (to_sensor_dev_attr(attr))->index; 1187 struct i2c_client *client = to_i2c_client(dev); 1188 struct lm93_data *data = i2c_get_clientdata(client); 1189 u32 val = simple_strtoul(buf, NULL, 10); 1190 int vccp = nr - 6; 1191 long vid; 1192 1193 mutex_lock(&data->update_lock); 1194 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) { 1195 vid = LM93_VID_FROM_REG(data->vid[vccp]); 1196 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0x0f) | 1197 LM93_IN_REL_TO_REG(val, 1, vid); 1198 lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp), 1199 data->vccp_limits[vccp]); 1200 } 1201 else { 1202 data->block7[nr].max = LM93_IN_TO_REG(nr,val); 1203 lm93_write_byte(client, LM93_REG_IN_MAX(nr), 1204 data->block7[nr].max); 1205 } 1206 mutex_unlock(&data->update_lock); 1207 return count; 1208} 1209 1210static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, 1211 show_in_max, store_in_max, 0); 1212static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, 1213 show_in_max, store_in_max, 1); 1214static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO, 1215 show_in_max, store_in_max, 2); 1216static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO, 1217 show_in_max, store_in_max, 3); 1218static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO, 1219 show_in_max, store_in_max, 4); 1220static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO, 1221 show_in_max, store_in_max, 5); 1222static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO, 1223 show_in_max, store_in_max, 6); 1224static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO, 1225 show_in_max, store_in_max, 7); 1226static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO, 1227 show_in_max, store_in_max, 8); 1228static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO, 1229 show_in_max, store_in_max, 9); 1230static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO, 1231 show_in_max, store_in_max, 10); 1232static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO, 1233 show_in_max, store_in_max, 11); 1234static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO, 1235 show_in_max, store_in_max, 12); 1236static SENSOR_DEVICE_ATTR(in14_max, S_IWUSR | S_IRUGO, 1237 show_in_max, store_in_max, 13); 1238static SENSOR_DEVICE_ATTR(in15_max, S_IWUSR | S_IRUGO, 1239 show_in_max, store_in_max, 14); 1240static SENSOR_DEVICE_ATTR(in16_max, S_IWUSR | S_IRUGO, 1241 show_in_max, store_in_max, 15); 1242 1243static ssize_t show_temp(struct device *dev, 1244 struct device_attribute *attr, char *buf) 1245{ 1246 int nr = (to_sensor_dev_attr(attr))->index; 1247 struct lm93_data *data = lm93_update_device(dev); 1248 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block2[nr])); 1249} 1250 1251static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 1252static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 1253static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2); 1254 1255static ssize_t show_temp_min(struct device *dev, 1256 struct device_attribute *attr, char *buf) 1257{ 1258 int nr = (to_sensor_dev_attr(attr))->index; 1259 struct lm93_data *data = lm93_update_device(dev); 1260 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].min)); 1261} 1262 1263static ssize_t store_temp_min(struct device *dev, struct device_attribute *attr, 1264 const char *buf, size_t count) 1265{ 1266 int nr = (to_sensor_dev_attr(attr))->index; 1267 struct i2c_client *client = to_i2c_client(dev); 1268 struct lm93_data *data = i2c_get_clientdata(client); 1269 long val = simple_strtol(buf, NULL, 10); 1270 1271 mutex_lock(&data->update_lock); 1272 data->temp_lim[nr].min = LM93_TEMP_TO_REG(val); 1273 lm93_write_byte(client, LM93_REG_TEMP_MIN(nr), data->temp_lim[nr].min); 1274 mutex_unlock(&data->update_lock); 1275 return count; 1276} 1277 1278static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, 1279 show_temp_min, store_temp_min, 0); 1280static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, 1281 show_temp_min, store_temp_min, 1); 1282static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, 1283 show_temp_min, store_temp_min, 2); 1284 1285static ssize_t show_temp_max(struct device *dev, 1286 struct device_attribute *attr, char *buf) 1287{ 1288 int nr = (to_sensor_dev_attr(attr))->index; 1289 struct lm93_data *data = lm93_update_device(dev); 1290 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].max)); 1291} 1292 1293static ssize_t store_temp_max(struct device *dev, struct device_attribute *attr, 1294 const char *buf, size_t count) 1295{ 1296 int nr = (to_sensor_dev_attr(attr))->index; 1297 struct i2c_client *client = to_i2c_client(dev); 1298 struct lm93_data *data = i2c_get_clientdata(client); 1299 long val = simple_strtol(buf, NULL, 10); 1300 1301 mutex_lock(&data->update_lock); 1302 data->temp_lim[nr].max = LM93_TEMP_TO_REG(val); 1303 lm93_write_byte(client, LM93_REG_TEMP_MAX(nr), data->temp_lim[nr].max); 1304 mutex_unlock(&data->update_lock); 1305 return count; 1306} 1307 1308static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, 1309 show_temp_max, store_temp_max, 0); 1310static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, 1311 show_temp_max, store_temp_max, 1); 1312static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, 1313 show_temp_max, store_temp_max, 2); 1314 1315static ssize_t show_temp_auto_base(struct device *dev, 1316 struct device_attribute *attr, char *buf) 1317{ 1318 int nr = (to_sensor_dev_attr(attr))->index; 1319 struct lm93_data *data = lm93_update_device(dev); 1320 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block10.base[nr])); 1321} 1322 1323static ssize_t store_temp_auto_base(struct device *dev, 1324 struct device_attribute *attr, 1325 const char *buf, size_t count) 1326{ 1327 int nr = (to_sensor_dev_attr(attr))->index; 1328 struct i2c_client *client = to_i2c_client(dev); 1329 struct lm93_data *data = i2c_get_clientdata(client); 1330 long val = simple_strtol(buf, NULL, 10); 1331 1332 mutex_lock(&data->update_lock); 1333 data->block10.base[nr] = LM93_TEMP_TO_REG(val); 1334 lm93_write_byte(client, LM93_REG_TEMP_BASE(nr), data->block10.base[nr]); 1335 mutex_unlock(&data->update_lock); 1336 return count; 1337} 1338 1339static SENSOR_DEVICE_ATTR(temp1_auto_base, S_IWUSR | S_IRUGO, 1340 show_temp_auto_base, store_temp_auto_base, 0); 1341static SENSOR_DEVICE_ATTR(temp2_auto_base, S_IWUSR | S_IRUGO, 1342 show_temp_auto_base, store_temp_auto_base, 1); 1343static SENSOR_DEVICE_ATTR(temp3_auto_base, S_IWUSR | S_IRUGO, 1344 show_temp_auto_base, store_temp_auto_base, 2); 1345 1346static ssize_t show_temp_auto_boost(struct device *dev, 1347 struct device_attribute *attr,char *buf) 1348{ 1349 int nr = (to_sensor_dev_attr(attr))->index; 1350 struct lm93_data *data = lm93_update_device(dev); 1351 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->boost[nr])); 1352} 1353 1354static ssize_t store_temp_auto_boost(struct device *dev, 1355 struct device_attribute *attr, 1356 const char *buf, size_t count) 1357{ 1358 int nr = (to_sensor_dev_attr(attr))->index; 1359 struct i2c_client *client = to_i2c_client(dev); 1360 struct lm93_data *data = i2c_get_clientdata(client); 1361 long val = simple_strtol(buf, NULL, 10); 1362 1363 mutex_lock(&data->update_lock); 1364 data->boost[nr] = LM93_TEMP_TO_REG(val); 1365 lm93_write_byte(client, LM93_REG_BOOST(nr), data->boost[nr]); 1366 mutex_unlock(&data->update_lock); 1367 return count; 1368} 1369 1370static SENSOR_DEVICE_ATTR(temp1_auto_boost, S_IWUSR | S_IRUGO, 1371 show_temp_auto_boost, store_temp_auto_boost, 0); 1372static SENSOR_DEVICE_ATTR(temp2_auto_boost, S_IWUSR | S_IRUGO, 1373 show_temp_auto_boost, store_temp_auto_boost, 1); 1374static SENSOR_DEVICE_ATTR(temp3_auto_boost, S_IWUSR | S_IRUGO, 1375 show_temp_auto_boost, store_temp_auto_boost, 2); 1376 1377static ssize_t show_temp_auto_boost_hyst(struct device *dev, 1378 struct device_attribute *attr, 1379 char *buf) 1380{ 1381 int nr = (to_sensor_dev_attr(attr))->index; 1382 struct lm93_data *data = lm93_update_device(dev); 1383 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr); 1384 return sprintf(buf,"%d\n", 1385 LM93_AUTO_BOOST_HYST_FROM_REGS(data, nr, mode)); 1386} 1387 1388static ssize_t store_temp_auto_boost_hyst(struct device *dev, 1389 struct device_attribute *attr, 1390 const char *buf, size_t count) 1391{ 1392 int nr = (to_sensor_dev_attr(attr))->index; 1393 struct i2c_client *client = to_i2c_client(dev); 1394 struct lm93_data *data = i2c_get_clientdata(client); 1395 u32 val = simple_strtoul(buf, NULL, 10); 1396 1397 mutex_lock(&data->update_lock); 1398 /* force 0.5C/bit mode */ 1399 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2); 1400 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20); 1401 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2); 1402 data->boost_hyst[nr/2] = LM93_AUTO_BOOST_HYST_TO_REG(data, val, nr, 1); 1403 lm93_write_byte(client, LM93_REG_BOOST_HYST(nr), 1404 data->boost_hyst[nr/2]); 1405 mutex_unlock(&data->update_lock); 1406 return count; 1407} 1408 1409static SENSOR_DEVICE_ATTR(temp1_auto_boost_hyst, S_IWUSR | S_IRUGO, 1410 show_temp_auto_boost_hyst, 1411 store_temp_auto_boost_hyst, 0); 1412static SENSOR_DEVICE_ATTR(temp2_auto_boost_hyst, S_IWUSR | S_IRUGO, 1413 show_temp_auto_boost_hyst, 1414 store_temp_auto_boost_hyst, 1); 1415static SENSOR_DEVICE_ATTR(temp3_auto_boost_hyst, S_IWUSR | S_IRUGO, 1416 show_temp_auto_boost_hyst, 1417 store_temp_auto_boost_hyst, 2); 1418 1419static ssize_t show_temp_auto_offset(struct device *dev, 1420 struct device_attribute *attr, char *buf) 1421{ 1422 struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr); 1423 int nr = s_attr->index; 1424 int ofs = s_attr->nr; 1425 struct lm93_data *data = lm93_update_device(dev); 1426 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr); 1427 return sprintf(buf,"%d\n", 1428 LM93_TEMP_AUTO_OFFSET_FROM_REG(data->block10.offset[ofs], 1429 nr,mode)); 1430} 1431 1432static ssize_t store_temp_auto_offset(struct device *dev, 1433 struct device_attribute *attr, 1434 const char *buf, size_t count) 1435{ 1436 struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr); 1437 int nr = s_attr->index; 1438 int ofs = s_attr->nr; 1439 struct i2c_client *client = to_i2c_client(dev); 1440 struct lm93_data *data = i2c_get_clientdata(client); 1441 u32 val = simple_strtoul(buf, NULL, 10); 1442 1443 mutex_lock(&data->update_lock); 1444 /* force 0.5C/bit mode */ 1445 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2); 1446 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20); 1447 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2); 1448 data->block10.offset[ofs] = LM93_TEMP_AUTO_OFFSET_TO_REG( 1449 data->block10.offset[ofs], val, nr, 1); 1450 lm93_write_byte(client, LM93_REG_TEMP_OFFSET(ofs), 1451 data->block10.offset[ofs]); 1452 mutex_unlock(&data->update_lock); 1453 return count; 1454} 1455 1456static SENSOR_DEVICE_ATTR_2(temp1_auto_offset1, S_IWUSR | S_IRUGO, 1457 show_temp_auto_offset, store_temp_auto_offset, 0, 0); 1458static SENSOR_DEVICE_ATTR_2(temp1_auto_offset2, S_IWUSR | S_IRUGO, 1459 show_temp_auto_offset, store_temp_auto_offset, 1, 0); 1460static SENSOR_DEVICE_ATTR_2(temp1_auto_offset3, S_IWUSR | S_IRUGO, 1461 show_temp_auto_offset, store_temp_auto_offset, 2, 0); 1462static SENSOR_DEVICE_ATTR_2(temp1_auto_offset4, S_IWUSR | S_IRUGO, 1463 show_temp_auto_offset, store_temp_auto_offset, 3, 0); 1464static SENSOR_DEVICE_ATTR_2(temp1_auto_offset5, S_IWUSR | S_IRUGO, 1465 show_temp_auto_offset, store_temp_auto_offset, 4, 0); 1466static SENSOR_DEVICE_ATTR_2(temp1_auto_offset6, S_IWUSR | S_IRUGO, 1467 show_temp_auto_offset, store_temp_auto_offset, 5, 0); 1468static SENSOR_DEVICE_ATTR_2(temp1_auto_offset7, S_IWUSR | S_IRUGO, 1469 show_temp_auto_offset, store_temp_auto_offset, 6, 0); 1470static SENSOR_DEVICE_ATTR_2(temp1_auto_offset8, S_IWUSR | S_IRUGO, 1471 show_temp_auto_offset, store_temp_auto_offset, 7, 0); 1472static SENSOR_DEVICE_ATTR_2(temp1_auto_offset9, S_IWUSR | S_IRUGO, 1473 show_temp_auto_offset, store_temp_auto_offset, 8, 0); 1474static SENSOR_DEVICE_ATTR_2(temp1_auto_offset10, S_IWUSR | S_IRUGO, 1475 show_temp_auto_offset, store_temp_auto_offset, 9, 0); 1476static SENSOR_DEVICE_ATTR_2(temp1_auto_offset11, S_IWUSR | S_IRUGO, 1477 show_temp_auto_offset, store_temp_auto_offset, 10, 0); 1478static SENSOR_DEVICE_ATTR_2(temp1_auto_offset12, S_IWUSR | S_IRUGO, 1479 show_temp_auto_offset, store_temp_auto_offset, 11, 0); 1480static SENSOR_DEVICE_ATTR_2(temp2_auto_offset1, S_IWUSR | S_IRUGO, 1481 show_temp_auto_offset, store_temp_auto_offset, 0, 1); 1482static SENSOR_DEVICE_ATTR_2(temp2_auto_offset2, S_IWUSR | S_IRUGO, 1483 show_temp_auto_offset, store_temp_auto_offset, 1, 1); 1484static SENSOR_DEVICE_ATTR_2(temp2_auto_offset3, S_IWUSR | S_IRUGO, 1485 show_temp_auto_offset, store_temp_auto_offset, 2, 1); 1486static SENSOR_DEVICE_ATTR_2(temp2_auto_offset4, S_IWUSR | S_IRUGO, 1487 show_temp_auto_offset, store_temp_auto_offset, 3, 1); 1488static SENSOR_DEVICE_ATTR_2(temp2_auto_offset5, S_IWUSR | S_IRUGO, 1489 show_temp_auto_offset, store_temp_auto_offset, 4, 1); 1490static SENSOR_DEVICE_ATTR_2(temp2_auto_offset6, S_IWUSR | S_IRUGO, 1491 show_temp_auto_offset, store_temp_auto_offset, 5, 1); 1492static SENSOR_DEVICE_ATTR_2(temp2_auto_offset7, S_IWUSR | S_IRUGO, 1493 show_temp_auto_offset, store_temp_auto_offset, 6, 1); 1494static SENSOR_DEVICE_ATTR_2(temp2_auto_offset8, S_IWUSR | S_IRUGO, 1495 show_temp_auto_offset, store_temp_auto_offset, 7, 1); 1496static SENSOR_DEVICE_ATTR_2(temp2_auto_offset9, S_IWUSR | S_IRUGO, 1497 show_temp_auto_offset, store_temp_auto_offset, 8, 1); 1498static SENSOR_DEVICE_ATTR_2(temp2_auto_offset10, S_IWUSR | S_IRUGO, 1499 show_temp_auto_offset, store_temp_auto_offset, 9, 1); 1500static SENSOR_DEVICE_ATTR_2(temp2_auto_offset11, S_IWUSR | S_IRUGO, 1501 show_temp_auto_offset, store_temp_auto_offset, 10, 1); 1502static SENSOR_DEVICE_ATTR_2(temp2_auto_offset12, S_IWUSR | S_IRUGO, 1503 show_temp_auto_offset, store_temp_auto_offset, 11, 1); 1504static SENSOR_DEVICE_ATTR_2(temp3_auto_offset1, S_IWUSR | S_IRUGO, 1505 show_temp_auto_offset, store_temp_auto_offset, 0, 2); 1506static SENSOR_DEVICE_ATTR_2(temp3_auto_offset2, S_IWUSR | S_IRUGO, 1507 show_temp_auto_offset, store_temp_auto_offset, 1, 2); 1508static SENSOR_DEVICE_ATTR_2(temp3_auto_offset3, S_IWUSR | S_IRUGO, 1509 show_temp_auto_offset, store_temp_auto_offset, 2, 2); 1510static SENSOR_DEVICE_ATTR_2(temp3_auto_offset4, S_IWUSR | S_IRUGO, 1511 show_temp_auto_offset, store_temp_auto_offset, 3, 2); 1512static SENSOR_DEVICE_ATTR_2(temp3_auto_offset5, S_IWUSR | S_IRUGO, 1513 show_temp_auto_offset, store_temp_auto_offset, 4, 2); 1514static SENSOR_DEVICE_ATTR_2(temp3_auto_offset6, S_IWUSR | S_IRUGO, 1515 show_temp_auto_offset, store_temp_auto_offset, 5, 2); 1516static SENSOR_DEVICE_ATTR_2(temp3_auto_offset7, S_IWUSR | S_IRUGO, 1517 show_temp_auto_offset, store_temp_auto_offset, 6, 2); 1518static SENSOR_DEVICE_ATTR_2(temp3_auto_offset8, S_IWUSR | S_IRUGO, 1519 show_temp_auto_offset, store_temp_auto_offset, 7, 2); 1520static SENSOR_DEVICE_ATTR_2(temp3_auto_offset9, S_IWUSR | S_IRUGO, 1521 show_temp_auto_offset, store_temp_auto_offset, 8, 2); 1522static SENSOR_DEVICE_ATTR_2(temp3_auto_offset10, S_IWUSR | S_IRUGO, 1523 show_temp_auto_offset, store_temp_auto_offset, 9, 2); 1524static SENSOR_DEVICE_ATTR_2(temp3_auto_offset11, S_IWUSR | S_IRUGO, 1525 show_temp_auto_offset, store_temp_auto_offset, 10, 2); 1526static SENSOR_DEVICE_ATTR_2(temp3_auto_offset12, S_IWUSR | S_IRUGO, 1527 show_temp_auto_offset, store_temp_auto_offset, 11, 2); 1528 1529static ssize_t show_temp_auto_pwm_min(struct device *dev, 1530 struct device_attribute *attr, char *buf) 1531{ 1532 int nr = (to_sensor_dev_attr(attr))->index; 1533 u8 reg, ctl4; 1534 struct lm93_data *data = lm93_update_device(dev); 1535 reg = data->auto_pwm_min_hyst[nr/2] >> 4 & 0x0f; 1536 ctl4 = data->block9[nr][LM93_PWM_CTL4]; 1537 return sprintf(buf,"%d\n",LM93_PWM_FROM_REG(reg, (ctl4 & 0x07) ? 1538 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ)); 1539} 1540 1541static ssize_t store_temp_auto_pwm_min(struct device *dev, 1542 struct device_attribute *attr, 1543 const char *buf, size_t count) 1544{ 1545 int nr = (to_sensor_dev_attr(attr))->index; 1546 struct i2c_client *client = to_i2c_client(dev); 1547 struct lm93_data *data = i2c_get_clientdata(client); 1548 u32 val = simple_strtoul(buf, NULL, 10); 1549 u8 reg, ctl4; 1550 1551 mutex_lock(&data->update_lock); 1552 reg = lm93_read_byte(client, LM93_REG_PWM_MIN_HYST(nr)); 1553 ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4)); 1554 reg = (reg & 0x0f) | 1555 LM93_PWM_TO_REG(val, (ctl4 & 0x07) ? 1556 LM93_PWM_MAP_LO_FREQ : 1557 LM93_PWM_MAP_HI_FREQ) << 4; 1558 data->auto_pwm_min_hyst[nr/2] = reg; 1559 lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg); 1560 mutex_unlock(&data->update_lock); 1561 return count; 1562} 1563 1564static SENSOR_DEVICE_ATTR(temp1_auto_pwm_min, S_IWUSR | S_IRUGO, 1565 show_temp_auto_pwm_min, 1566 store_temp_auto_pwm_min, 0); 1567static SENSOR_DEVICE_ATTR(temp2_auto_pwm_min, S_IWUSR | S_IRUGO, 1568 show_temp_auto_pwm_min, 1569 store_temp_auto_pwm_min, 1); 1570static SENSOR_DEVICE_ATTR(temp3_auto_pwm_min, S_IWUSR | S_IRUGO, 1571 show_temp_auto_pwm_min, 1572 store_temp_auto_pwm_min, 2); 1573 1574static ssize_t show_temp_auto_offset_hyst(struct device *dev, 1575 struct device_attribute *attr, char *buf) 1576{ 1577 int nr = (to_sensor_dev_attr(attr))->index; 1578 struct lm93_data *data = lm93_update_device(dev); 1579 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr); 1580 return sprintf(buf,"%d\n",LM93_TEMP_OFFSET_FROM_REG( 1581 data->auto_pwm_min_hyst[nr/2], mode)); 1582} 1583 1584static ssize_t store_temp_auto_offset_hyst(struct device *dev, 1585 struct device_attribute *attr, 1586 const char *buf, size_t count) 1587{ 1588 int nr = (to_sensor_dev_attr(attr))->index; 1589 struct i2c_client *client = to_i2c_client(dev); 1590 struct lm93_data *data = i2c_get_clientdata(client); 1591 u32 val = simple_strtoul(buf, NULL, 10); 1592 u8 reg; 1593 1594 mutex_lock(&data->update_lock); 1595 /* force 0.5C/bit mode */ 1596 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2); 1597 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20); 1598 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2); 1599 reg = data->auto_pwm_min_hyst[nr/2]; 1600 reg = (reg & 0xf0) | (LM93_TEMP_OFFSET_TO_REG(val, 1) & 0x0f); 1601 data->auto_pwm_min_hyst[nr/2] = reg; 1602 lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg); 1603 mutex_unlock(&data->update_lock); 1604 return count; 1605} 1606 1607static SENSOR_DEVICE_ATTR(temp1_auto_offset_hyst, S_IWUSR | S_IRUGO, 1608 show_temp_auto_offset_hyst, 1609 store_temp_auto_offset_hyst, 0); 1610static SENSOR_DEVICE_ATTR(temp2_auto_offset_hyst, S_IWUSR | S_IRUGO, 1611 show_temp_auto_offset_hyst, 1612 store_temp_auto_offset_hyst, 1); 1613static SENSOR_DEVICE_ATTR(temp3_auto_offset_hyst, S_IWUSR | S_IRUGO, 1614 show_temp_auto_offset_hyst, 1615 store_temp_auto_offset_hyst, 2); 1616 1617static ssize_t show_fan_input(struct device *dev, 1618 struct device_attribute *attr, char *buf) 1619{ 1620 struct sensor_device_attribute *s_attr = to_sensor_dev_attr(attr); 1621 int nr = s_attr->index; 1622 struct lm93_data *data = lm93_update_device(dev); 1623 1624 return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block5[nr])); 1625} 1626 1627static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0); 1628static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1); 1629static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2); 1630static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_input, NULL, 3); 1631 1632static ssize_t show_fan_min(struct device *dev, 1633 struct device_attribute *attr, char *buf) 1634{ 1635 int nr = (to_sensor_dev_attr(attr))->index; 1636 struct lm93_data *data = lm93_update_device(dev); 1637 1638 return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block8[nr])); 1639} 1640 1641static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr, 1642 const char *buf, size_t count) 1643{ 1644 int nr = (to_sensor_dev_attr(attr))->index; 1645 struct i2c_client *client = to_i2c_client(dev); 1646 struct lm93_data *data = i2c_get_clientdata(client); 1647 u32 val = simple_strtoul(buf, NULL, 10); 1648 1649 mutex_lock(&data->update_lock); 1650 data->block8[nr] = LM93_FAN_TO_REG(val); 1651 lm93_write_word(client,LM93_REG_FAN_MIN(nr),data->block8[nr]); 1652 mutex_unlock(&data->update_lock); 1653 return count; 1654} 1655 1656static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, 1657 show_fan_min, store_fan_min, 0); 1658static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, 1659 show_fan_min, store_fan_min, 1); 1660static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, 1661 show_fan_min, store_fan_min, 2); 1662static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, 1663 show_fan_min, store_fan_min, 3); 1664 1665/* some tedious bit-twiddling here to deal with the register format: 1666 1667 data->sf_tach_to_pwm: (tach to pwm mapping bits) 1668 1669 bit | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 1670 T4:P2 T4:P1 T3:P2 T3:P1 T2:P2 T2:P1 T1:P2 T1:P1 1671 1672 data->sfc2: (enable bits) 1673 1674 bit | 3 | 2 | 1 | 0 1675 T4 T3 T2 T1 1676*/ 1677 1678static ssize_t show_fan_smart_tach(struct device *dev, 1679 struct device_attribute *attr, char *buf) 1680{ 1681 int nr = (to_sensor_dev_attr(attr))->index; 1682 struct lm93_data *data = lm93_update_device(dev); 1683 long rc = 0; 1684 int mapping; 1685 1686 /* extract the relevant mapping */ 1687 mapping = (data->sf_tach_to_pwm >> (nr * 2)) & 0x03; 1688 1689 /* if there's a mapping and it's enabled */ 1690 if (mapping && ((data->sfc2 >> nr) & 0x01)) 1691 rc = mapping; 1692 return sprintf(buf,"%ld\n",rc); 1693} 1694 1695/* helper function - must grab data->update_lock before calling 1696 fan is 0-3, indicating fan1-fan4 */ 1697static void lm93_write_fan_smart_tach(struct i2c_client *client, 1698 struct lm93_data *data, int fan, long value) 1699{ 1700 /* insert the new mapping and write it out */ 1701 data->sf_tach_to_pwm = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM); 1702 data->sf_tach_to_pwm &= ~(0x3 << fan * 2); 1703 data->sf_tach_to_pwm |= value << fan * 2; 1704 lm93_write_byte(client, LM93_REG_SF_TACH_TO_PWM, data->sf_tach_to_pwm); 1705 1706 /* insert the enable bit and write it out */ 1707 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2); 1708 if (value) 1709 data->sfc2 |= 1 << fan; 1710 else 1711 data->sfc2 &= ~(1 << fan); 1712 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2); 1713} 1714 1715static ssize_t store_fan_smart_tach(struct device *dev, 1716 struct device_attribute *attr, 1717 const char *buf, size_t count) 1718{ 1719 int nr = (to_sensor_dev_attr(attr))->index; 1720 struct i2c_client *client = to_i2c_client(dev); 1721 struct lm93_data *data = i2c_get_clientdata(client); 1722 u32 val = simple_strtoul(buf, NULL, 10); 1723 1724 mutex_lock(&data->update_lock); 1725 /* sanity test, ignore the write otherwise */ 1726 if (0 <= val && val <= 2) { 1727 /* can't enable if pwm freq is 22.5KHz */ 1728 if (val) { 1729 u8 ctl4 = lm93_read_byte(client, 1730 LM93_REG_PWM_CTL(val-1,LM93_PWM_CTL4)); 1731 if ((ctl4 & 0x07) == 0) 1732 val = 0; 1733 } 1734 lm93_write_fan_smart_tach(client, data, nr, val); 1735 } 1736 mutex_unlock(&data->update_lock); 1737 return count; 1738} 1739 1740static SENSOR_DEVICE_ATTR(fan1_smart_tach, S_IWUSR | S_IRUGO, 1741 show_fan_smart_tach, store_fan_smart_tach, 0); 1742static SENSOR_DEVICE_ATTR(fan2_smart_tach, S_IWUSR | S_IRUGO, 1743 show_fan_smart_tach, store_fan_smart_tach, 1); 1744static SENSOR_DEVICE_ATTR(fan3_smart_tach, S_IWUSR | S_IRUGO, 1745 show_fan_smart_tach, store_fan_smart_tach, 2); 1746static SENSOR_DEVICE_ATTR(fan4_smart_tach, S_IWUSR | S_IRUGO, 1747 show_fan_smart_tach, store_fan_smart_tach, 3); 1748 1749static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, 1750 char *buf) 1751{ 1752 int nr = (to_sensor_dev_attr(attr))->index; 1753 struct lm93_data *data = lm93_update_device(dev); 1754 u8 ctl2, ctl4; 1755 long rc; 1756 1757 ctl2 = data->block9[nr][LM93_PWM_CTL2]; 1758 ctl4 = data->block9[nr][LM93_PWM_CTL4]; 1759 if (ctl2 & 0x01) /* show user commanded value if enabled */ 1760 rc = data->pwm_override[nr]; 1761 else /* show present h/w value if manual pwm disabled */ 1762 rc = LM93_PWM_FROM_REG(ctl2 >> 4, (ctl4 & 0x07) ? 1763 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ); 1764 return sprintf(buf,"%ld\n",rc); 1765} 1766 1767static ssize_t store_pwm(struct device *dev, struct device_attribute *attr, 1768 const char *buf, size_t count) 1769{ 1770 int nr = (to_sensor_dev_attr(attr))->index; 1771 struct i2c_client *client = to_i2c_client(dev); 1772 struct lm93_data *data = i2c_get_clientdata(client); 1773 u32 val = simple_strtoul(buf, NULL, 10); 1774 u8 ctl2, ctl4; 1775 1776 mutex_lock(&data->update_lock); 1777 ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2)); 1778 ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4)); 1779 ctl2 = (ctl2 & 0x0f) | LM93_PWM_TO_REG(val,(ctl4 & 0x07) ? 1780 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ) << 4; 1781 /* save user commanded value */ 1782 data->pwm_override[nr] = LM93_PWM_FROM_REG(ctl2 >> 4, 1783 (ctl4 & 0x07) ? LM93_PWM_MAP_LO_FREQ : 1784 LM93_PWM_MAP_HI_FREQ); 1785 lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2); 1786 mutex_unlock(&data->update_lock); 1787 return count; 1788} 1789 1790static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0); 1791static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1); 1792 1793static ssize_t show_pwm_enable(struct device *dev, 1794 struct device_attribute *attr, char *buf) 1795{ 1796 int nr = (to_sensor_dev_attr(attr))->index; 1797 struct lm93_data *data = lm93_update_device(dev); 1798 u8 ctl2; 1799 long rc; 1800 1801 ctl2 = data->block9[nr][LM93_PWM_CTL2]; 1802 if (ctl2 & 0x01) /* manual override enabled ? */ 1803 rc = ((ctl2 & 0xF0) == 0xF0) ? 0 : 1; 1804 else 1805 rc = 2; 1806 return sprintf(buf,"%ld\n",rc); 1807} 1808 1809static ssize_t store_pwm_enable(struct device *dev, 1810 struct device_attribute *attr, 1811 const char *buf, size_t count) 1812{ 1813 int nr = (to_sensor_dev_attr(attr))->index; 1814 struct i2c_client *client = to_i2c_client(dev); 1815 struct lm93_data *data = i2c_get_clientdata(client); 1816 u32 val = simple_strtoul(buf, NULL, 10); 1817 u8 ctl2; 1818 1819 mutex_lock(&data->update_lock); 1820 ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2)); 1821 1822 switch (val) { 1823 case 0: 1824 ctl2 |= 0xF1; /* enable manual override, set PWM to max */ 1825 break; 1826 case 1: ctl2 |= 0x01; /* enable manual override */ 1827 break; 1828 case 2: ctl2 &= ~0x01; /* disable manual override */ 1829 break; 1830 default: 1831 mutex_unlock(&data->update_lock); 1832 return -EINVAL; 1833 } 1834 1835 lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2); 1836 mutex_unlock(&data->update_lock); 1837 return count; 1838} 1839 1840static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, 1841 show_pwm_enable, store_pwm_enable, 0); 1842static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, 1843 show_pwm_enable, store_pwm_enable, 1); 1844 1845static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr, 1846 char *buf) 1847{ 1848 int nr = (to_sensor_dev_attr(attr))->index; 1849 struct lm93_data *data = lm93_update_device(dev); 1850 u8 ctl4; 1851 1852 ctl4 = data->block9[nr][LM93_PWM_CTL4]; 1853 return sprintf(buf,"%d\n",LM93_PWM_FREQ_FROM_REG(ctl4)); 1854} 1855 1856/* helper function - must grab data->update_lock before calling 1857 pwm is 0-1, indicating pwm1-pwm2 1858 this disables smart tach for all tach channels bound to the given pwm */ 1859static void lm93_disable_fan_smart_tach(struct i2c_client *client, 1860 struct lm93_data *data, int pwm) 1861{ 1862 int mapping = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM); 1863 int mask; 1864 1865 /* collapse the mapping into a mask of enable bits */ 1866 mapping = (mapping >> pwm) & 0x55; 1867 mask = mapping & 0x01; 1868 mask |= (mapping & 0x04) >> 1; 1869 mask |= (mapping & 0x10) >> 2; 1870 mask |= (mapping & 0x40) >> 3; 1871 1872 /* disable smart tach according to the mask */ 1873 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2); 1874 data->sfc2 &= ~mask; 1875 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2); 1876} 1877 1878static ssize_t store_pwm_freq(struct device *dev, 1879 struct device_attribute *attr, 1880 const char *buf, size_t count) 1881{ 1882 int nr = (to_sensor_dev_attr(attr))->index; 1883 struct i2c_client *client = to_i2c_client(dev); 1884 struct lm93_data *data = i2c_get_clientdata(client); 1885 u32 val = simple_strtoul(buf, NULL, 10); 1886 u8 ctl4; 1887 1888 mutex_lock(&data->update_lock); 1889 ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4)); 1890 ctl4 = (ctl4 & 0xf8) | LM93_PWM_FREQ_TO_REG(val); 1891 data->block9[nr][LM93_PWM_CTL4] = ctl4; 1892 /* ctl4 == 0 -> 22.5KHz -> disable smart tach */ 1893 if (!ctl4) 1894 lm93_disable_fan_smart_tach(client, data, nr); 1895 lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4), ctl4); 1896 mutex_unlock(&data->update_lock); 1897 return count; 1898} 1899 1900static SENSOR_DEVICE_ATTR(pwm1_freq, S_IWUSR | S_IRUGO, 1901 show_pwm_freq, store_pwm_freq, 0); 1902static SENSOR_DEVICE_ATTR(pwm2_freq, S_IWUSR | S_IRUGO, 1903 show_pwm_freq, store_pwm_freq, 1); 1904 1905static ssize_t show_pwm_auto_channels(struct device *dev, 1906 struct device_attribute *attr, char *buf) 1907{ 1908 int nr = (to_sensor_dev_attr(attr))->index; 1909 struct lm93_data *data = lm93_update_device(dev); 1910 return sprintf(buf,"%d\n",data->block9[nr][LM93_PWM_CTL1]); 1911} 1912 1913static ssize_t store_pwm_auto_channels(struct device *dev, 1914 struct device_attribute *attr, 1915 const char *buf, size_t count) 1916{ 1917 int nr = (to_sensor_dev_attr(attr))->index; 1918 struct i2c_client *client = to_i2c_client(dev); 1919 struct lm93_data *data = i2c_get_clientdata(client); 1920 u32 val = simple_strtoul(buf, NULL, 10); 1921 1922 mutex_lock(&data->update_lock); 1923 data->block9[nr][LM93_PWM_CTL1] = SENSORS_LIMIT(val, 0, 255); 1924 lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL1), 1925 data->block9[nr][LM93_PWM_CTL1]); 1926 mutex_unlock(&data->update_lock); 1927 return count; 1928} 1929 1930static SENSOR_DEVICE_ATTR(pwm1_auto_channels, S_IWUSR | S_IRUGO, 1931 show_pwm_auto_channels, store_pwm_auto_channels, 0); 1932static SENSOR_DEVICE_ATTR(pwm2_auto_channels, S_IWUSR | S_IRUGO, 1933 show_pwm_auto_channels, store_pwm_auto_channels, 1); 1934 1935static ssize_t show_pwm_auto_spinup_min(struct device *dev, 1936 struct device_attribute *attr,char *buf) 1937{ 1938 int nr = (to_sensor_dev_attr(attr))->index; 1939 struct lm93_data *data = lm93_update_device(dev); 1940 u8 ctl3, ctl4; 1941 1942 ctl3 = data->block9[nr][LM93_PWM_CTL3]; 1943 ctl4 = data->block9[nr][LM93_PWM_CTL4]; 1944 return sprintf(buf,"%d\n", 1945 LM93_PWM_FROM_REG(ctl3 & 0x0f, (ctl4 & 0x07) ? 1946 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ)); 1947} 1948 1949static ssize_t store_pwm_auto_spinup_min(struct device *dev, 1950 struct device_attribute *attr, 1951 const char *buf, size_t count) 1952{ 1953 int nr = (to_sensor_dev_attr(attr))->index; 1954 struct i2c_client *client = to_i2c_client(dev); 1955 struct lm93_data *data = i2c_get_clientdata(client); 1956 u32 val = simple_strtoul(buf, NULL, 10); 1957 u8 ctl3, ctl4; 1958 1959 mutex_lock(&data->update_lock); 1960 ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3)); 1961 ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL4)); 1962 ctl3 = (ctl3 & 0xf0) | LM93_PWM_TO_REG(val, (ctl4 & 0x07) ? 1963 LM93_PWM_MAP_LO_FREQ : 1964 LM93_PWM_MAP_HI_FREQ); 1965 data->block9[nr][LM93_PWM_CTL3] = ctl3; 1966 lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3); 1967 mutex_unlock(&data->update_lock); 1968 return count; 1969} 1970 1971static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_min, S_IWUSR | S_IRUGO, 1972 show_pwm_auto_spinup_min, 1973 store_pwm_auto_spinup_min, 0); 1974static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_min, S_IWUSR | S_IRUGO, 1975 show_pwm_auto_spinup_min, 1976 store_pwm_auto_spinup_min, 1); 1977 1978static ssize_t show_pwm_auto_spinup_time(struct device *dev, 1979 struct device_attribute *attr, char *buf) 1980{ 1981 int nr = (to_sensor_dev_attr(attr))->index; 1982 struct lm93_data *data = lm93_update_device(dev); 1983 return sprintf(buf,"%d\n",LM93_SPINUP_TIME_FROM_REG( 1984 data->block9[nr][LM93_PWM_CTL3])); 1985} 1986 1987static ssize_t store_pwm_auto_spinup_time(struct device *dev, 1988 struct device_attribute *attr, 1989 const char *buf, size_t count) 1990{ 1991 int nr = (to_sensor_dev_attr(attr))->index; 1992 struct i2c_client *client = to_i2c_client(dev); 1993 struct lm93_data *data = i2c_get_clientdata(client); 1994 u32 val = simple_strtoul(buf, NULL, 10); 1995 u8 ctl3; 1996 1997 mutex_lock(&data->update_lock); 1998 ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3)); 1999 ctl3 = (ctl3 & 0x1f) | (LM93_SPINUP_TIME_TO_REG(val) << 5 & 0xe0); 2000 data->block9[nr][LM93_PWM_CTL3] = ctl3; 2001 lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3); 2002 mutex_unlock(&data->update_lock); 2003 return count; 2004} 2005 2006static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_time, S_IWUSR | S_IRUGO, 2007 show_pwm_auto_spinup_time, 2008 store_pwm_auto_spinup_time, 0); 2009static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_time, S_IWUSR | S_IRUGO, 2010 show_pwm_auto_spinup_time, 2011 store_pwm_auto_spinup_time, 1); 2012 2013static ssize_t show_pwm_auto_prochot_ramp(struct device *dev, 2014 struct device_attribute *attr, char *buf) 2015{ 2016 struct lm93_data *data = lm93_update_device(dev); 2017 return sprintf(buf,"%d\n", 2018 LM93_RAMP_FROM_REG(data->pwm_ramp_ctl >> 4 & 0x0f)); 2019} 2020 2021static ssize_t store_pwm_auto_prochot_ramp(struct device *dev, 2022 struct device_attribute *attr, 2023 const char *buf, size_t count) 2024{ 2025 struct i2c_client *client = to_i2c_client(dev); 2026 struct lm93_data *data = i2c_get_clientdata(client); 2027 u32 val = simple_strtoul(buf, NULL, 10); 2028 u8 ramp; 2029 2030 mutex_lock(&data->update_lock); 2031 ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL); 2032 ramp = (ramp & 0x0f) | (LM93_RAMP_TO_REG(val) << 4 & 0xf0); 2033 lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp); 2034 mutex_unlock(&data->update_lock); 2035 return count; 2036} 2037 2038static DEVICE_ATTR(pwm_auto_prochot_ramp, S_IRUGO | S_IWUSR, 2039 show_pwm_auto_prochot_ramp, 2040 store_pwm_auto_prochot_ramp); 2041 2042static ssize_t show_pwm_auto_vrdhot_ramp(struct device *dev, 2043 struct device_attribute *attr, char *buf) 2044{ 2045 struct lm93_data *data = lm93_update_device(dev); 2046 return sprintf(buf,"%d\n", 2047 LM93_RAMP_FROM_REG(data->pwm_ramp_ctl & 0x0f)); 2048} 2049 2050static ssize_t store_pwm_auto_vrdhot_ramp(struct device *dev, 2051 struct device_attribute *attr, 2052 const char *buf, size_t count) 2053{ 2054 struct i2c_client *client = to_i2c_client(dev); 2055 struct lm93_data *data = i2c_get_clientdata(client); 2056 u32 val = simple_strtoul(buf, NULL, 10); 2057 u8 ramp; 2058 2059 mutex_lock(&data->update_lock); 2060 ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL); 2061 ramp = (ramp & 0xf0) | (LM93_RAMP_TO_REG(val) & 0x0f); 2062 lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp); 2063 mutex_unlock(&data->update_lock); 2064 return 0; 2065} 2066 2067static DEVICE_ATTR(pwm_auto_vrdhot_ramp, S_IRUGO | S_IWUSR, 2068 show_pwm_auto_vrdhot_ramp, 2069 store_pwm_auto_vrdhot_ramp); 2070 2071static ssize_t show_vid(struct device *dev, struct device_attribute *attr, 2072 char *buf) 2073{ 2074 int nr = (to_sensor_dev_attr(attr))->index; 2075 struct lm93_data *data = lm93_update_device(dev); 2076 return sprintf(buf,"%d\n",LM93_VID_FROM_REG(data->vid[nr])); 2077} 2078 2079static SENSOR_DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL, 0); 2080static SENSOR_DEVICE_ATTR(cpu1_vid, S_IRUGO, show_vid, NULL, 1); 2081 2082static ssize_t show_prochot(struct device *dev, struct device_attribute *attr, 2083 char *buf) 2084{ 2085 int nr = (to_sensor_dev_attr(attr))->index; 2086 struct lm93_data *data = lm93_update_device(dev); 2087 return sprintf(buf,"%d\n",data->block4[nr].cur); 2088} 2089 2090static SENSOR_DEVICE_ATTR(prochot1, S_IRUGO, show_prochot, NULL, 0); 2091static SENSOR_DEVICE_ATTR(prochot2, S_IRUGO, show_prochot, NULL, 1); 2092 2093static ssize_t show_prochot_avg(struct device *dev, 2094 struct device_attribute *attr, char *buf) 2095{ 2096 int nr = (to_sensor_dev_attr(attr))->index; 2097 struct lm93_data *data = lm93_update_device(dev); 2098 return sprintf(buf,"%d\n",data->block4[nr].avg); 2099} 2100 2101static SENSOR_DEVICE_ATTR(prochot1_avg, S_IRUGO, show_prochot_avg, NULL, 0); 2102static SENSOR_DEVICE_ATTR(prochot2_avg, S_IRUGO, show_prochot_avg, NULL, 1); 2103 2104static ssize_t show_prochot_max(struct device *dev, 2105 struct device_attribute *attr, char *buf) 2106{ 2107 int nr = (to_sensor_dev_attr(attr))->index; 2108 struct lm93_data *data = lm93_update_device(dev); 2109 return sprintf(buf,"%d\n",data->prochot_max[nr]); 2110} 2111 2112static ssize_t store_prochot_max(struct device *dev, 2113 struct device_attribute *attr, 2114 const char *buf, size_t count) 2115{ 2116 int nr = (to_sensor_dev_attr(attr))->index; 2117 struct i2c_client *client = to_i2c_client(dev); 2118 struct lm93_data *data = i2c_get_clientdata(client); 2119 u32 val = simple_strtoul(buf, NULL, 10); 2120 2121 mutex_lock(&data->update_lock); 2122 data->prochot_max[nr] = LM93_PROCHOT_TO_REG(val); 2123 lm93_write_byte(client, LM93_REG_PROCHOT_MAX(nr), 2124 data->prochot_max[nr]); 2125 mutex_unlock(&data->update_lock); 2126 return count; 2127} 2128 2129static SENSOR_DEVICE_ATTR(prochot1_max, S_IWUSR | S_IRUGO, 2130 show_prochot_max, store_prochot_max, 0); 2131static SENSOR_DEVICE_ATTR(prochot2_max, S_IWUSR | S_IRUGO, 2132 show_prochot_max, store_prochot_max, 1); 2133 2134static const u8 prochot_override_mask[] = { 0x80, 0x40 }; 2135 2136static ssize_t show_prochot_override(struct device *dev, 2137 struct device_attribute *attr, char *buf) 2138{ 2139 int nr = (to_sensor_dev_attr(attr))->index; 2140 struct lm93_data *data = lm93_update_device(dev); 2141 return sprintf(buf,"%d\n", 2142 (data->prochot_override & prochot_override_mask[nr]) ? 1 : 0); 2143} 2144 2145static ssize_t store_prochot_override(struct device *dev, 2146 struct device_attribute *attr, 2147 const char *buf, size_t count) 2148{ 2149 int nr = (to_sensor_dev_attr(attr))->index; 2150 struct i2c_client *client = to_i2c_client(dev); 2151 struct lm93_data *data = i2c_get_clientdata(client); 2152 u32 val = simple_strtoul(buf, NULL, 10); 2153 2154 mutex_lock(&data->update_lock); 2155 if (val) 2156 data->prochot_override |= prochot_override_mask[nr]; 2157 else 2158 data->prochot_override &= (~prochot_override_mask[nr]); 2159 lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE, 2160 data->prochot_override); 2161 mutex_unlock(&data->update_lock); 2162 return count; 2163} 2164 2165static SENSOR_DEVICE_ATTR(prochot1_override, S_IWUSR | S_IRUGO, 2166 show_prochot_override, store_prochot_override, 0); 2167static SENSOR_DEVICE_ATTR(prochot2_override, S_IWUSR | S_IRUGO, 2168 show_prochot_override, store_prochot_override, 1); 2169 2170static ssize_t show_prochot_interval(struct device *dev, 2171 struct device_attribute *attr, char *buf) 2172{ 2173 int nr = (to_sensor_dev_attr(attr))->index; 2174 struct lm93_data *data = lm93_update_device(dev); 2175 u8 tmp; 2176 if (nr==1) 2177 tmp = (data->prochot_interval & 0xf0) >> 4; 2178 else 2179 tmp = data->prochot_interval & 0x0f; 2180 return sprintf(buf,"%d\n",LM93_INTERVAL_FROM_REG(tmp)); 2181} 2182 2183static ssize_t store_prochot_interval(struct device *dev, 2184 struct device_attribute *attr, 2185 const char *buf, size_t count) 2186{ 2187 int nr = (to_sensor_dev_attr(attr))->index; 2188 struct i2c_client *client = to_i2c_client(dev); 2189 struct lm93_data *data = i2c_get_clientdata(client); 2190 u32 val = simple_strtoul(buf, NULL, 10); 2191 u8 tmp; 2192 2193 mutex_lock(&data->update_lock); 2194 tmp = lm93_read_byte(client, LM93_REG_PROCHOT_INTERVAL); 2195 if (nr==1) 2196 tmp = (tmp & 0x0f) | (LM93_INTERVAL_TO_REG(val) << 4); 2197 else 2198 tmp = (tmp & 0xf0) | LM93_INTERVAL_TO_REG(val); 2199 data->prochot_interval = tmp; 2200 lm93_write_byte(client, LM93_REG_PROCHOT_INTERVAL, tmp); 2201 mutex_unlock(&data->update_lock); 2202 return count; 2203} 2204 2205static SENSOR_DEVICE_ATTR(prochot1_interval, S_IWUSR | S_IRUGO, 2206 show_prochot_interval, store_prochot_interval, 0); 2207static SENSOR_DEVICE_ATTR(prochot2_interval, S_IWUSR | S_IRUGO, 2208 show_prochot_interval, store_prochot_interval, 1); 2209 2210static ssize_t show_prochot_override_duty_cycle(struct device *dev, 2211 struct device_attribute *attr, 2212 char *buf) 2213{ 2214 struct lm93_data *data = lm93_update_device(dev); 2215 return sprintf(buf,"%d\n",data->prochot_override & 0x0f); 2216} 2217 2218static ssize_t store_prochot_override_duty_cycle(struct device *dev, 2219 struct device_attribute *attr, 2220 const char *buf, size_t count) 2221{ 2222 struct i2c_client *client = to_i2c_client(dev); 2223 struct lm93_data *data = i2c_get_clientdata(client); 2224 u32 val = simple_strtoul(buf, NULL, 10); 2225 2226 mutex_lock(&data->update_lock); 2227 data->prochot_override = (data->prochot_override & 0xf0) | 2228 SENSORS_LIMIT(val, 0, 15); 2229 lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE, 2230 data->prochot_override); 2231 mutex_unlock(&data->update_lock); 2232 return count; 2233} 2234 2235static DEVICE_ATTR(prochot_override_duty_cycle, S_IRUGO | S_IWUSR, 2236 show_prochot_override_duty_cycle, 2237 store_prochot_override_duty_cycle); 2238 2239static ssize_t show_prochot_short(struct device *dev, 2240 struct device_attribute *attr, char *buf) 2241{ 2242 struct lm93_data *data = lm93_update_device(dev); 2243 return sprintf(buf,"%d\n",(data->config & 0x10) ? 1 : 0); 2244} 2245 2246static ssize_t store_prochot_short(struct device *dev, 2247 struct device_attribute *attr, 2248 const char *buf, size_t count) 2249{ 2250 struct i2c_client *client = to_i2c_client(dev); 2251 struct lm93_data *data = i2c_get_clientdata(client); 2252 u32 val = simple_strtoul(buf, NULL, 10); 2253 2254 mutex_lock(&data->update_lock); 2255 if (val) 2256 data->config |= 0x10; 2257 else 2258 data->config &= ~0x10; 2259 lm93_write_byte(client, LM93_REG_CONFIG, data->config); 2260 mutex_unlock(&data->update_lock); 2261 return count; 2262} 2263 2264static DEVICE_ATTR(prochot_short, S_IRUGO | S_IWUSR, 2265 show_prochot_short, store_prochot_short); 2266 2267static ssize_t show_vrdhot(struct device *dev, struct device_attribute *attr, 2268 char *buf) 2269{ 2270 int nr = (to_sensor_dev_attr(attr))->index; 2271 struct lm93_data *data = lm93_update_device(dev); 2272 return sprintf(buf,"%d\n", 2273 data->block1.host_status_1 & (1 << (nr+4)) ? 1 : 0); 2274} 2275 2276static SENSOR_DEVICE_ATTR(vrdhot1, S_IRUGO, show_vrdhot, NULL, 0); 2277static SENSOR_DEVICE_ATTR(vrdhot2, S_IRUGO, show_vrdhot, NULL, 1); 2278 2279static ssize_t show_gpio(struct device *dev, struct device_attribute *attr, 2280 char *buf) 2281{ 2282 struct lm93_data *data = lm93_update_device(dev); 2283 return sprintf(buf,"%d\n",LM93_GPI_FROM_REG(data->gpi)); 2284} 2285 2286static DEVICE_ATTR(gpio, S_IRUGO, show_gpio, NULL); 2287 2288static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, 2289 char *buf) 2290{ 2291 struct lm93_data *data = lm93_update_device(dev); 2292 return sprintf(buf,"%d\n",LM93_ALARMS_FROM_REG(data->block1)); 2293} 2294 2295static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 2296 2297static struct attribute *lm93_attrs[] = { 2298 &sensor_dev_attr_in1_input.dev_attr.attr, 2299 &sensor_dev_attr_in2_input.dev_attr.attr, 2300 &sensor_dev_attr_in3_input.dev_attr.attr, 2301 &sensor_dev_attr_in4_input.dev_attr.attr, 2302 &sensor_dev_attr_in5_input.dev_attr.attr, 2303 &sensor_dev_attr_in6_input.dev_attr.attr, 2304 &sensor_dev_attr_in7_input.dev_attr.attr, 2305 &sensor_dev_attr_in8_input.dev_attr.attr, 2306 &sensor_dev_attr_in9_input.dev_attr.attr, 2307 &sensor_dev_attr_in10_input.dev_attr.attr, 2308 &sensor_dev_attr_in11_input.dev_attr.attr, 2309 &sensor_dev_attr_in12_input.dev_attr.attr, 2310 &sensor_dev_attr_in13_input.dev_attr.attr, 2311 &sensor_dev_attr_in14_input.dev_attr.attr, 2312 &sensor_dev_attr_in15_input.dev_attr.attr, 2313 &sensor_dev_attr_in16_input.dev_attr.attr, 2314 &sensor_dev_attr_in1_min.dev_attr.attr, 2315 &sensor_dev_attr_in2_min.dev_attr.attr, 2316 &sensor_dev_attr_in3_min.dev_attr.attr, 2317 &sensor_dev_attr_in4_min.dev_attr.attr, 2318 &sensor_dev_attr_in5_min.dev_attr.attr, 2319 &sensor_dev_attr_in6_min.dev_attr.attr, 2320 &sensor_dev_attr_in7_min.dev_attr.attr, 2321 &sensor_dev_attr_in8_min.dev_attr.attr, 2322 &sensor_dev_attr_in9_min.dev_attr.attr, 2323 &sensor_dev_attr_in10_min.dev_attr.attr, 2324 &sensor_dev_attr_in11_min.dev_attr.attr, 2325 &sensor_dev_attr_in12_min.dev_attr.attr, 2326 &sensor_dev_attr_in13_min.dev_attr.attr, 2327 &sensor_dev_attr_in14_min.dev_attr.attr, 2328 &sensor_dev_attr_in15_min.dev_attr.attr, 2329 &sensor_dev_attr_in16_min.dev_attr.attr, 2330 &sensor_dev_attr_in1_max.dev_attr.attr, 2331 &sensor_dev_attr_in2_max.dev_attr.attr, 2332 &sensor_dev_attr_in3_max.dev_attr.attr, 2333 &sensor_dev_attr_in4_max.dev_attr.attr, 2334 &sensor_dev_attr_in5_max.dev_attr.attr, 2335 &sensor_dev_attr_in6_max.dev_attr.attr, 2336 &sensor_dev_attr_in7_max.dev_attr.attr, 2337 &sensor_dev_attr_in8_max.dev_attr.attr, 2338 &sensor_dev_attr_in9_max.dev_attr.attr, 2339 &sensor_dev_attr_in10_max.dev_attr.attr, 2340 &sensor_dev_attr_in11_max.dev_attr.attr, 2341 &sensor_dev_attr_in12_max.dev_attr.attr, 2342 &sensor_dev_attr_in13_max.dev_attr.attr, 2343 &sensor_dev_attr_in14_max.dev_attr.attr, 2344 &sensor_dev_attr_in15_max.dev_attr.attr, 2345 &sensor_dev_attr_in16_max.dev_attr.attr, 2346 &sensor_dev_attr_temp1_input.dev_attr.attr, 2347 &sensor_dev_attr_temp2_input.dev_attr.attr, 2348 &sensor_dev_attr_temp3_input.dev_attr.attr, 2349 &sensor_dev_attr_temp1_min.dev_attr.attr, 2350 &sensor_dev_attr_temp2_min.dev_attr.attr, 2351 &sensor_dev_attr_temp3_min.dev_attr.attr, 2352 &sensor_dev_attr_temp1_max.dev_attr.attr, 2353 &sensor_dev_attr_temp2_max.dev_attr.attr, 2354 &sensor_dev_attr_temp3_max.dev_attr.attr, 2355 &sensor_dev_attr_temp1_auto_base.dev_attr.attr, 2356 &sensor_dev_attr_temp2_auto_base.dev_attr.attr, 2357 &sensor_dev_attr_temp3_auto_base.dev_attr.attr, 2358 &sensor_dev_attr_temp1_auto_boost.dev_attr.attr, 2359 &sensor_dev_attr_temp2_auto_boost.dev_attr.attr, 2360 &sensor_dev_attr_temp3_auto_boost.dev_attr.attr, 2361 &sensor_dev_attr_temp1_auto_boost_hyst.dev_attr.attr, 2362 &sensor_dev_attr_temp2_auto_boost_hyst.dev_attr.attr, 2363 &sensor_dev_attr_temp3_auto_boost_hyst.dev_attr.attr, 2364 &sensor_dev_attr_temp1_auto_offset1.dev_attr.attr, 2365 &sensor_dev_attr_temp1_auto_offset2.dev_attr.attr, 2366 &sensor_dev_attr_temp1_auto_offset3.dev_attr.attr, 2367 &sensor_dev_attr_temp1_auto_offset4.dev_attr.attr, 2368 &sensor_dev_attr_temp1_auto_offset5.dev_attr.attr, 2369 &sensor_dev_attr_temp1_auto_offset6.dev_attr.attr, 2370 &sensor_dev_attr_temp1_auto_offset7.dev_attr.attr, 2371 &sensor_dev_attr_temp1_auto_offset8.dev_attr.attr, 2372 &sensor_dev_attr_temp1_auto_offset9.dev_attr.attr, 2373 &sensor_dev_attr_temp1_auto_offset10.dev_attr.attr, 2374 &sensor_dev_attr_temp1_auto_offset11.dev_attr.attr, 2375 &sensor_dev_attr_temp1_auto_offset12.dev_attr.attr, 2376 &sensor_dev_attr_temp2_auto_offset1.dev_attr.attr, 2377 &sensor_dev_attr_temp2_auto_offset2.dev_attr.attr, 2378 &sensor_dev_attr_temp2_auto_offset3.dev_attr.attr, 2379 &sensor_dev_attr_temp2_auto_offset4.dev_attr.attr, 2380 &sensor_dev_attr_temp2_auto_offset5.dev_attr.attr, 2381 &sensor_dev_attr_temp2_auto_offset6.dev_attr.attr, 2382 &sensor_dev_attr_temp2_auto_offset7.dev_attr.attr, 2383 &sensor_dev_attr_temp2_auto_offset8.dev_attr.attr, 2384 &sensor_dev_attr_temp2_auto_offset9.dev_attr.attr, 2385 &sensor_dev_attr_temp2_auto_offset10.dev_attr.attr, 2386 &sensor_dev_attr_temp2_auto_offset11.dev_attr.attr, 2387 &sensor_dev_attr_temp2_auto_offset12.dev_attr.attr, 2388 &sensor_dev_attr_temp3_auto_offset1.dev_attr.attr, 2389 &sensor_dev_attr_temp3_auto_offset2.dev_attr.attr, 2390 &sensor_dev_attr_temp3_auto_offset3.dev_attr.attr, 2391 &sensor_dev_attr_temp3_auto_offset4.dev_attr.attr, 2392 &sensor_dev_attr_temp3_auto_offset5.dev_attr.attr, 2393 &sensor_dev_attr_temp3_auto_offset6.dev_attr.attr, 2394 &sensor_dev_attr_temp3_auto_offset7.dev_attr.attr, 2395 &sensor_dev_attr_temp3_auto_offset8.dev_attr.attr, 2396 &sensor_dev_attr_temp3_auto_offset9.dev_attr.attr, 2397 &sensor_dev_attr_temp3_auto_offset10.dev_attr.attr, 2398 &sensor_dev_attr_temp3_auto_offset11.dev_attr.attr, 2399 &sensor_dev_attr_temp3_auto_offset12.dev_attr.attr, 2400 &sensor_dev_attr_temp1_auto_pwm_min.dev_attr.attr, 2401 &sensor_dev_attr_temp2_auto_pwm_min.dev_attr.attr, 2402 &sensor_dev_attr_temp3_auto_pwm_min.dev_attr.attr, 2403 &sensor_dev_attr_temp1_auto_offset_hyst.dev_attr.attr, 2404 &sensor_dev_attr_temp2_auto_offset_hyst.dev_attr.attr, 2405 &sensor_dev_attr_temp3_auto_offset_hyst.dev_attr.attr, 2406 &sensor_dev_attr_fan1_input.dev_attr.attr, 2407 &sensor_dev_attr_fan2_input.dev_attr.attr, 2408 &sensor_dev_attr_fan3_input.dev_attr.attr, 2409 &sensor_dev_attr_fan4_input.dev_attr.attr, 2410 &sensor_dev_attr_fan1_min.dev_attr.attr, 2411 &sensor_dev_attr_fan2_min.dev_attr.attr, 2412 &sensor_dev_attr_fan3_min.dev_attr.attr, 2413 &sensor_dev_attr_fan4_min.dev_attr.attr, 2414 &sensor_dev_attr_fan1_smart_tach.dev_attr.attr, 2415 &sensor_dev_attr_fan2_smart_tach.dev_attr.attr, 2416 &sensor_dev_attr_fan3_smart_tach.dev_attr.attr, 2417 &sensor_dev_attr_fan4_smart_tach.dev_attr.attr, 2418 &sensor_dev_attr_pwm1.dev_attr.attr, 2419 &sensor_dev_attr_pwm2.dev_attr.attr, 2420 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 2421 &sensor_dev_attr_pwm2_enable.dev_attr.attr, 2422 &sensor_dev_attr_pwm1_freq.dev_attr.attr, 2423 &sensor_dev_attr_pwm2_freq.dev_attr.attr, 2424 &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr, 2425 &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr, 2426 &sensor_dev_attr_pwm1_auto_spinup_min.dev_attr.attr, 2427 &sensor_dev_attr_pwm2_auto_spinup_min.dev_attr.attr, 2428 &sensor_dev_attr_pwm1_auto_spinup_time.dev_attr.attr, 2429 &sensor_dev_attr_pwm2_auto_spinup_time.dev_attr.attr, 2430 &dev_attr_pwm_auto_prochot_ramp.attr, 2431 &dev_attr_pwm_auto_vrdhot_ramp.attr, 2432 &sensor_dev_attr_cpu0_vid.dev_attr.attr, 2433 &sensor_dev_attr_cpu1_vid.dev_attr.attr, 2434 &sensor_dev_attr_prochot1.dev_attr.attr, 2435 &sensor_dev_attr_prochot2.dev_attr.attr, 2436 &sensor_dev_attr_prochot1_avg.dev_attr.attr, 2437 &sensor_dev_attr_prochot2_avg.dev_attr.attr, 2438 &sensor_dev_attr_prochot1_max.dev_attr.attr, 2439 &sensor_dev_attr_prochot2_max.dev_attr.attr, 2440 &sensor_dev_attr_prochot1_override.dev_attr.attr, 2441 &sensor_dev_attr_prochot2_override.dev_attr.attr, 2442 &sensor_dev_attr_prochot1_interval.dev_attr.attr, 2443 &sensor_dev_attr_prochot2_interval.dev_attr.attr, 2444 &dev_attr_prochot_override_duty_cycle.attr, 2445 &dev_attr_prochot_short.attr, 2446 &sensor_dev_attr_vrdhot1.dev_attr.attr, 2447 &sensor_dev_attr_vrdhot2.dev_attr.attr, 2448 &dev_attr_gpio.attr, 2449 &dev_attr_alarms.attr, 2450 NULL 2451}; 2452 2453static struct attribute_group lm93_attr_grp = { 2454 .attrs = lm93_attrs, 2455}; 2456 2457static void lm93_init_client(struct i2c_client *client) 2458{ 2459 int i; 2460 u8 reg; 2461 2462 /* configure VID pin input thresholds */ 2463 reg = lm93_read_byte(client, LM93_REG_GPI_VID_CTL); 2464 lm93_write_byte(client, LM93_REG_GPI_VID_CTL, 2465 reg | (vid_agtl ? 0x03 : 0x00)); 2466 2467 if (init) { 2468 /* enable #ALERT pin */ 2469 reg = lm93_read_byte(client, LM93_REG_CONFIG); 2470 lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x08); 2471 2472 /* enable ASF mode for BMC status registers */ 2473 reg = lm93_read_byte(client, LM93_REG_STATUS_CONTROL); 2474 lm93_write_byte(client, LM93_REG_STATUS_CONTROL, reg | 0x02); 2475 2476 /* set sleep state to S0 */ 2477 lm93_write_byte(client, LM93_REG_SLEEP_CONTROL, 0); 2478 2479 /* unmask #VRDHOT and dynamic VCCP (if nec) error events */ 2480 reg = lm93_read_byte(client, LM93_REG_MISC_ERR_MASK); 2481 reg &= ~0x03; 2482 reg &= ~(vccp_limit_type[0] ? 0x10 : 0); 2483 reg &= ~(vccp_limit_type[1] ? 0x20 : 0); 2484 lm93_write_byte(client, LM93_REG_MISC_ERR_MASK, reg); 2485 } 2486 2487 /* start monitoring */ 2488 reg = lm93_read_byte(client, LM93_REG_CONFIG); 2489 lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x01); 2490 2491 /* spin until ready */ 2492 for (i=0; i<20; i++) { 2493 msleep(10); 2494 if ((lm93_read_byte(client, LM93_REG_CONFIG) & 0x80) == 0x80) 2495 return; 2496 } 2497 2498 dev_warn(&client->dev,"timed out waiting for sensor " 2499 "chip to signal ready!\n"); 2500} 2501 2502/* Return 0 if detection is successful, -ENODEV otherwise */ 2503static int lm93_detect(struct i2c_client *client, struct i2c_board_info *info) 2504{ 2505 struct i2c_adapter *adapter = client->adapter; 2506 int mfr, ver; 2507 2508 if (!i2c_check_functionality(adapter, LM93_SMBUS_FUNC_MIN)) 2509 return -ENODEV; 2510 2511 /* detection */ 2512 mfr = lm93_read_byte(client, LM93_REG_MFR_ID); 2513 if (mfr != 0x01) { 2514 dev_dbg(&adapter->dev, 2515 "detect failed, bad manufacturer id 0x%02x!\n", mfr); 2516 return -ENODEV; 2517 } 2518 2519 ver = lm93_read_byte(client, LM93_REG_VER); 2520 if (ver != LM93_MFR_ID && ver != LM93_MFR_ID_PROTOTYPE) { 2521 dev_dbg(&adapter->dev, 2522 "detect failed, bad version id 0x%02x!\n", ver); 2523 return -ENODEV; 2524 } 2525 2526 strlcpy(info->type, "lm93", I2C_NAME_SIZE); 2527 dev_dbg(&adapter->dev,"loading %s at %d,0x%02x\n", 2528 client->name, i2c_adapter_id(client->adapter), 2529 client->addr); 2530 2531 return 0; 2532} 2533 2534static int lm93_probe(struct i2c_client *client, 2535 const struct i2c_device_id *id) 2536{ 2537 struct lm93_data *data; 2538 int err, func; 2539 void (*update)(struct lm93_data *, struct i2c_client *); 2540 2541 /* choose update routine based on bus capabilities */ 2542 func = i2c_get_functionality(client->adapter); 2543 if (((LM93_SMBUS_FUNC_FULL & func) == LM93_SMBUS_FUNC_FULL) && 2544 (!disable_block)) { 2545 dev_dbg(&client->dev, "using SMBus block data transactions\n"); 2546 update = lm93_update_client_full; 2547 } else if ((LM93_SMBUS_FUNC_MIN & func) == LM93_SMBUS_FUNC_MIN) { 2548 dev_dbg(&client->dev, "disabled SMBus block data " 2549 "transactions\n"); 2550 update = lm93_update_client_min; 2551 } else { 2552 dev_dbg(&client->dev, "detect failed, " 2553 "smbus byte and/or word data not supported!\n"); 2554 err = -ENODEV; 2555 goto err_out; 2556 } 2557 2558 data = kzalloc(sizeof(struct lm93_data), GFP_KERNEL); 2559 if (!data) { 2560 dev_dbg(&client->dev, "out of memory!\n"); 2561 err = -ENOMEM; 2562 goto err_out; 2563 } 2564 i2c_set_clientdata(client, data); 2565 2566 /* housekeeping */ 2567 data->valid = 0; 2568 data->update = update; 2569 mutex_init(&data->update_lock); 2570 2571 /* initialize the chip */ 2572 lm93_init_client(client); 2573 2574 err = sysfs_create_group(&client->dev.kobj, &lm93_attr_grp); 2575 if (err) 2576 goto err_free; 2577 2578 /* Register hwmon driver class */ 2579 data->hwmon_dev = hwmon_device_register(&client->dev); 2580 if ( !IS_ERR(data->hwmon_dev)) 2581 return 0; 2582 2583 err = PTR_ERR(data->hwmon_dev); 2584 dev_err(&client->dev, "error registering hwmon device.\n"); 2585 sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp); 2586err_free: 2587 kfree(data); 2588err_out: 2589 return err; 2590} 2591 2592static int lm93_remove(struct i2c_client *client) 2593{ 2594 struct lm93_data *data = i2c_get_clientdata(client); 2595 2596 hwmon_device_unregister(data->hwmon_dev); 2597 sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp); 2598 2599 kfree(data); 2600 return 0; 2601} 2602 2603static const struct i2c_device_id lm93_id[] = { 2604 { "lm93", 0 }, 2605 { } 2606}; 2607MODULE_DEVICE_TABLE(i2c, lm93_id); 2608 2609static struct i2c_driver lm93_driver = { 2610 .class = I2C_CLASS_HWMON, 2611 .driver = { 2612 .name = "lm93", 2613 }, 2614 .probe = lm93_probe, 2615 .remove = lm93_remove, 2616 .id_table = lm93_id, 2617 .detect = lm93_detect, 2618 .address_list = normal_i2c, 2619}; 2620 2621static int __init lm93_init(void) 2622{ 2623 return i2c_add_driver(&lm93_driver); 2624} 2625 2626static void __exit lm93_exit(void) 2627{ 2628 i2c_del_driver(&lm93_driver); 2629} 2630 2631MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>, " 2632 "Hans J. Koch <hjk@linutronix.de"); 2633MODULE_DESCRIPTION("LM93 driver"); 2634MODULE_LICENSE("GPL"); 2635 2636module_init(lm93_init); 2637module_exit(lm93_exit); 2638