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