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