1 /* 2 * adm1026.c - Part of lm_sensors, Linux kernel modules for hardware 3 * monitoring 4 * Copyright (C) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com> 5 * Copyright (C) 2004 Justin Thiessen <jthiessen@penguincomputing.com> 6 * 7 * Chip details at: 8 * 9 * <http://www.onsemi.com/PowerSolutions/product.do?id=ADM1026> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 24 */ 25 26 #include <linux/module.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/jiffies.h> 30 #include <linux/i2c.h> 31 #include <linux/hwmon.h> 32 #include <linux/hwmon-sysfs.h> 33 #include <linux/hwmon-vid.h> 34 #include <linux/err.h> 35 #include <linux/mutex.h> 36 37 /* Addresses to scan */ 38 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 39 40 static int gpio_input[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, 41 -1, -1, -1, -1, -1, -1, -1, -1 }; 42 static int gpio_output[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, 43 -1, -1, -1, -1, -1, -1, -1, -1 }; 44 static int gpio_inverted[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, 45 -1, -1, -1, -1, -1, -1, -1, -1 }; 46 static int gpio_normal[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, 47 -1, -1, -1, -1, -1, -1, -1, -1 }; 48 static int gpio_fan[8] = { -1, -1, -1, -1, -1, -1, -1, -1 }; 49 module_param_array(gpio_input, int, NULL, 0); 50 MODULE_PARM_DESC(gpio_input, "List of GPIO pins (0-16) to program as inputs"); 51 module_param_array(gpio_output, int, NULL, 0); 52 MODULE_PARM_DESC(gpio_output, 53 "List of GPIO pins (0-16) to program as outputs"); 54 module_param_array(gpio_inverted, int, NULL, 0); 55 MODULE_PARM_DESC(gpio_inverted, 56 "List of GPIO pins (0-16) to program as inverted"); 57 module_param_array(gpio_normal, int, NULL, 0); 58 MODULE_PARM_DESC(gpio_normal, 59 "List of GPIO pins (0-16) to program as normal/non-inverted"); 60 module_param_array(gpio_fan, int, NULL, 0); 61 MODULE_PARM_DESC(gpio_fan, "List of GPIO pins (0-7) to program as fan tachs"); 62 63 /* Many ADM1026 constants specified below */ 64 65 /* The ADM1026 registers */ 66 #define ADM1026_REG_CONFIG1 0x00 67 #define CFG1_MONITOR 0x01 68 #define CFG1_INT_ENABLE 0x02 69 #define CFG1_INT_CLEAR 0x04 70 #define CFG1_AIN8_9 0x08 71 #define CFG1_THERM_HOT 0x10 72 #define CFG1_DAC_AFC 0x20 73 #define CFG1_PWM_AFC 0x40 74 #define CFG1_RESET 0x80 75 76 #define ADM1026_REG_CONFIG2 0x01 77 /* CONFIG2 controls FAN0/GPIO0 through FAN7/GPIO7 */ 78 79 #define ADM1026_REG_CONFIG3 0x07 80 #define CFG3_GPIO16_ENABLE 0x01 81 #define CFG3_CI_CLEAR 0x02 82 #define CFG3_VREF_250 0x04 83 #define CFG3_GPIO16_DIR 0x40 84 #define CFG3_GPIO16_POL 0x80 85 86 #define ADM1026_REG_E2CONFIG 0x13 87 #define E2CFG_READ 0x01 88 #define E2CFG_WRITE 0x02 89 #define E2CFG_ERASE 0x04 90 #define E2CFG_ROM 0x08 91 #define E2CFG_CLK_EXT 0x80 92 93 /* 94 * There are 10 general analog inputs and 7 dedicated inputs 95 * They are: 96 * 0 - 9 = AIN0 - AIN9 97 * 10 = Vbat 98 * 11 = 3.3V Standby 99 * 12 = 3.3V Main 100 * 13 = +5V 101 * 14 = Vccp (CPU core voltage) 102 * 15 = +12V 103 * 16 = -12V 104 */ 105 static u16 ADM1026_REG_IN[] = { 106 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 107 0x36, 0x37, 0x27, 0x29, 0x26, 0x2a, 108 0x2b, 0x2c, 0x2d, 0x2e, 0x2f 109 }; 110 static u16 ADM1026_REG_IN_MIN[] = { 111 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 112 0x5e, 0x5f, 0x6d, 0x49, 0x6b, 0x4a, 113 0x4b, 0x4c, 0x4d, 0x4e, 0x4f 114 }; 115 static u16 ADM1026_REG_IN_MAX[] = { 116 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 117 0x56, 0x57, 0x6c, 0x41, 0x6a, 0x42, 118 0x43, 0x44, 0x45, 0x46, 0x47 119 }; 120 121 /* 122 * Temperatures are: 123 * 0 - Internal 124 * 1 - External 1 125 * 2 - External 2 126 */ 127 static u16 ADM1026_REG_TEMP[] = { 0x1f, 0x28, 0x29 }; 128 static u16 ADM1026_REG_TEMP_MIN[] = { 0x69, 0x48, 0x49 }; 129 static u16 ADM1026_REG_TEMP_MAX[] = { 0x68, 0x40, 0x41 }; 130 static u16 ADM1026_REG_TEMP_TMIN[] = { 0x10, 0x11, 0x12 }; 131 static u16 ADM1026_REG_TEMP_THERM[] = { 0x0d, 0x0e, 0x0f }; 132 static u16 ADM1026_REG_TEMP_OFFSET[] = { 0x1e, 0x6e, 0x6f }; 133 134 #define ADM1026_REG_FAN(nr) (0x38 + (nr)) 135 #define ADM1026_REG_FAN_MIN(nr) (0x60 + (nr)) 136 #define ADM1026_REG_FAN_DIV_0_3 0x02 137 #define ADM1026_REG_FAN_DIV_4_7 0x03 138 139 #define ADM1026_REG_DAC 0x04 140 #define ADM1026_REG_PWM 0x05 141 142 #define ADM1026_REG_GPIO_CFG_0_3 0x08 143 #define ADM1026_REG_GPIO_CFG_4_7 0x09 144 #define ADM1026_REG_GPIO_CFG_8_11 0x0a 145 #define ADM1026_REG_GPIO_CFG_12_15 0x0b 146 /* CFG_16 in REG_CFG3 */ 147 #define ADM1026_REG_GPIO_STATUS_0_7 0x24 148 #define ADM1026_REG_GPIO_STATUS_8_15 0x25 149 /* STATUS_16 in REG_STATUS4 */ 150 #define ADM1026_REG_GPIO_MASK_0_7 0x1c 151 #define ADM1026_REG_GPIO_MASK_8_15 0x1d 152 /* MASK_16 in REG_MASK4 */ 153 154 #define ADM1026_REG_COMPANY 0x16 155 #define ADM1026_REG_VERSTEP 0x17 156 /* These are the recognized values for the above regs */ 157 #define ADM1026_COMPANY_ANALOG_DEV 0x41 158 #define ADM1026_VERSTEP_GENERIC 0x40 159 #define ADM1026_VERSTEP_ADM1026 0x44 160 161 #define ADM1026_REG_MASK1 0x18 162 #define ADM1026_REG_MASK2 0x19 163 #define ADM1026_REG_MASK3 0x1a 164 #define ADM1026_REG_MASK4 0x1b 165 166 #define ADM1026_REG_STATUS1 0x20 167 #define ADM1026_REG_STATUS2 0x21 168 #define ADM1026_REG_STATUS3 0x22 169 #define ADM1026_REG_STATUS4 0x23 170 171 #define ADM1026_FAN_ACTIVATION_TEMP_HYST -6 172 #define ADM1026_FAN_CONTROL_TEMP_RANGE 20 173 #define ADM1026_PWM_MAX 255 174 175 /* 176 * Conversions. Rounding and limit checking is only done on the TO_REG 177 * variants. Note that you should be a bit careful with which arguments 178 * these macros are called: arguments may be evaluated more than once. 179 */ 180 181 /* 182 * IN are scaled according to built-in resistors. These are the 183 * voltages corresponding to 3/4 of full scale (192 or 0xc0) 184 * NOTE: The -12V input needs an additional factor to account 185 * for the Vref pullup resistor. 186 * NEG12_OFFSET = SCALE * Vref / V-192 - Vref 187 * = 13875 * 2.50 / 1.875 - 2500 188 * = 16000 189 * 190 * The values in this table are based on Table II, page 15 of the 191 * datasheet. 192 */ 193 static int adm1026_scaling[] = { /* .001 Volts */ 194 2250, 2250, 2250, 2250, 2250, 2250, 195 1875, 1875, 1875, 1875, 3000, 3330, 196 3330, 4995, 2250, 12000, 13875 197 }; 198 #define NEG12_OFFSET 16000 199 #define SCALE(val, from, to) (((val)*(to) + ((from)/2))/(from)) 200 #define INS_TO_REG(n, val) (clamp_val(SCALE(val, adm1026_scaling[n], 192),\ 201 0, 255)) 202 #define INS_FROM_REG(n, val) (SCALE(val, 192, adm1026_scaling[n])) 203 204 /* 205 * FAN speed is measured using 22.5kHz clock and counts for 2 pulses 206 * and we assume a 2 pulse-per-rev fan tach signal 207 * 22500 kHz * 60 (sec/min) * 2 (pulse) / 2 (pulse/rev) == 1350000 208 */ 209 #define FAN_TO_REG(val, div) ((val) <= 0 ? 0xff : \ 210 clamp_val(1350000 / ((val) * (div)), \ 211 1, 254)) 212 #define FAN_FROM_REG(val, div) ((val) == 0 ? -1 : (val) == 0xff ? 0 : \ 213 1350000 / ((val) * (div))) 214 #define DIV_FROM_REG(val) (1 << (val)) 215 #define DIV_TO_REG(val) ((val) >= 8 ? 3 : (val) >= 4 ? 2 : (val) >= 2 ? 1 : 0) 216 217 /* Temperature is reported in 1 degC increments */ 218 #define TEMP_TO_REG(val) (clamp_val(((val) + ((val) < 0 ? -500 : 500)) \ 219 / 1000, -127, 127)) 220 #define TEMP_FROM_REG(val) ((val) * 1000) 221 #define OFFSET_TO_REG(val) (clamp_val(((val) + ((val) < 0 ? -500 : 500)) \ 222 / 1000, -127, 127)) 223 #define OFFSET_FROM_REG(val) ((val) * 1000) 224 225 #define PWM_TO_REG(val) (clamp_val(val, 0, 255)) 226 #define PWM_FROM_REG(val) (val) 227 228 #define PWM_MIN_TO_REG(val) ((val) & 0xf0) 229 #define PWM_MIN_FROM_REG(val) (((val) & 0xf0) + ((val) >> 4)) 230 231 /* 232 * Analog output is a voltage, and scaled to millivolts. The datasheet 233 * indicates that the DAC could be used to drive the fans, but in our 234 * example board (Arima HDAMA) it isn't connected to the fans at all. 235 */ 236 #define DAC_TO_REG(val) (clamp_val(((((val) * 255) + 500) / 2500), 0, 255)) 237 #define DAC_FROM_REG(val) (((val) * 2500) / 255) 238 239 /* 240 * Chip sampling rates 241 * 242 * Some sensors are not updated more frequently than once per second 243 * so it doesn't make sense to read them more often than that. 244 * We cache the results and return the saved data if the driver 245 * is called again before a second has elapsed. 246 * 247 * Also, there is significant configuration data for this chip 248 * So, we keep the config data up to date in the cache 249 * when it is written and only sample it once every 5 *minutes* 250 */ 251 #define ADM1026_DATA_INTERVAL (1 * HZ) 252 #define ADM1026_CONFIG_INTERVAL (5 * 60 * HZ) 253 254 /* 255 * We allow for multiple chips in a single system. 256 * 257 * For each registered ADM1026, we need to keep state information 258 * at client->data. The adm1026_data structure is dynamically 259 * allocated, when a new client structure is allocated. 260 */ 261 262 struct pwm_data { 263 u8 pwm; 264 u8 enable; 265 u8 auto_pwm_min; 266 }; 267 268 struct adm1026_data { 269 struct device *hwmon_dev; 270 271 struct mutex update_lock; 272 int valid; /* !=0 if following fields are valid */ 273 unsigned long last_reading; /* In jiffies */ 274 unsigned long last_config; /* In jiffies */ 275 276 u8 in[17]; /* Register value */ 277 u8 in_max[17]; /* Register value */ 278 u8 in_min[17]; /* Register value */ 279 s8 temp[3]; /* Register value */ 280 s8 temp_min[3]; /* Register value */ 281 s8 temp_max[3]; /* Register value */ 282 s8 temp_tmin[3]; /* Register value */ 283 s8 temp_crit[3]; /* Register value */ 284 s8 temp_offset[3]; /* Register value */ 285 u8 fan[8]; /* Register value */ 286 u8 fan_min[8]; /* Register value */ 287 u8 fan_div[8]; /* Decoded value */ 288 struct pwm_data pwm1; /* Pwm control values */ 289 u8 vrm; /* VRM version */ 290 u8 analog_out; /* Register value (DAC) */ 291 long alarms; /* Register encoding, combined */ 292 long alarm_mask; /* Register encoding, combined */ 293 long gpio; /* Register encoding, combined */ 294 long gpio_mask; /* Register encoding, combined */ 295 u8 gpio_config[17]; /* Decoded value */ 296 u8 config1; /* Register value */ 297 u8 config2; /* Register value */ 298 u8 config3; /* Register value */ 299 }; 300 301 static int adm1026_probe(struct i2c_client *client, 302 const struct i2c_device_id *id); 303 static int adm1026_detect(struct i2c_client *client, 304 struct i2c_board_info *info); 305 static int adm1026_remove(struct i2c_client *client); 306 static int adm1026_read_value(struct i2c_client *client, u8 reg); 307 static int adm1026_write_value(struct i2c_client *client, u8 reg, int value); 308 static void adm1026_print_gpio(struct i2c_client *client); 309 static void adm1026_fixup_gpio(struct i2c_client *client); 310 static struct adm1026_data *adm1026_update_device(struct device *dev); 311 static void adm1026_init_client(struct i2c_client *client); 312 313 314 static const struct i2c_device_id adm1026_id[] = { 315 { "adm1026", 0 }, 316 { } 317 }; 318 MODULE_DEVICE_TABLE(i2c, adm1026_id); 319 320 static struct i2c_driver adm1026_driver = { 321 .class = I2C_CLASS_HWMON, 322 .driver = { 323 .name = "adm1026", 324 }, 325 .probe = adm1026_probe, 326 .remove = adm1026_remove, 327 .id_table = adm1026_id, 328 .detect = adm1026_detect, 329 .address_list = normal_i2c, 330 }; 331 332 static int adm1026_read_value(struct i2c_client *client, u8 reg) 333 { 334 int res; 335 336 if (reg < 0x80) { 337 /* "RAM" locations */ 338 res = i2c_smbus_read_byte_data(client, reg) & 0xff; 339 } else { 340 /* EEPROM, do nothing */ 341 res = 0; 342 } 343 return res; 344 } 345 346 static int adm1026_write_value(struct i2c_client *client, u8 reg, int value) 347 { 348 int res; 349 350 if (reg < 0x80) { 351 /* "RAM" locations */ 352 res = i2c_smbus_write_byte_data(client, reg, value); 353 } else { 354 /* EEPROM, do nothing */ 355 res = 0; 356 } 357 return res; 358 } 359 360 static void adm1026_init_client(struct i2c_client *client) 361 { 362 int value, i; 363 struct adm1026_data *data = i2c_get_clientdata(client); 364 365 dev_dbg(&client->dev, "Initializing device\n"); 366 /* Read chip config */ 367 data->config1 = adm1026_read_value(client, ADM1026_REG_CONFIG1); 368 data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2); 369 data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3); 370 371 /* Inform user of chip config */ 372 dev_dbg(&client->dev, "ADM1026_REG_CONFIG1 is: 0x%02x\n", 373 data->config1); 374 if ((data->config1 & CFG1_MONITOR) == 0) { 375 dev_dbg(&client->dev, 376 "Monitoring not currently enabled.\n"); 377 } 378 if (data->config1 & CFG1_INT_ENABLE) { 379 dev_dbg(&client->dev, 380 "SMBALERT interrupts are enabled.\n"); 381 } 382 if (data->config1 & CFG1_AIN8_9) { 383 dev_dbg(&client->dev, 384 "in8 and in9 enabled. temp3 disabled.\n"); 385 } else { 386 dev_dbg(&client->dev, 387 "temp3 enabled. in8 and in9 disabled.\n"); 388 } 389 if (data->config1 & CFG1_THERM_HOT) { 390 dev_dbg(&client->dev, 391 "Automatic THERM, PWM, and temp limits enabled.\n"); 392 } 393 394 if (data->config3 & CFG3_GPIO16_ENABLE) { 395 dev_dbg(&client->dev, 396 "GPIO16 enabled. THERM pin disabled.\n"); 397 } else { 398 dev_dbg(&client->dev, 399 "THERM pin enabled. GPIO16 disabled.\n"); 400 } 401 if (data->config3 & CFG3_VREF_250) 402 dev_dbg(&client->dev, "Vref is 2.50 Volts.\n"); 403 else 404 dev_dbg(&client->dev, "Vref is 1.82 Volts.\n"); 405 /* Read and pick apart the existing GPIO configuration */ 406 value = 0; 407 for (i = 0; i <= 15; ++i) { 408 if ((i & 0x03) == 0) { 409 value = adm1026_read_value(client, 410 ADM1026_REG_GPIO_CFG_0_3 + i / 4); 411 } 412 data->gpio_config[i] = value & 0x03; 413 value >>= 2; 414 } 415 data->gpio_config[16] = (data->config3 >> 6) & 0x03; 416 417 /* ... and then print it */ 418 adm1026_print_gpio(client); 419 420 /* 421 * If the user asks us to reprogram the GPIO config, then 422 * do it now. 423 */ 424 if (gpio_input[0] != -1 || gpio_output[0] != -1 425 || gpio_inverted[0] != -1 || gpio_normal[0] != -1 426 || gpio_fan[0] != -1) { 427 adm1026_fixup_gpio(client); 428 } 429 430 /* 431 * WE INTENTIONALLY make no changes to the limits, 432 * offsets, pwms, fans and zones. If they were 433 * configured, we don't want to mess with them. 434 * If they weren't, the default is 100% PWM, no 435 * control and will suffice until 'sensors -s' 436 * can be run by the user. We DO set the default 437 * value for pwm1.auto_pwm_min to its maximum 438 * so that enabling automatic pwm fan control 439 * without first setting a value for pwm1.auto_pwm_min 440 * will not result in potentially dangerous fan speed decrease. 441 */ 442 data->pwm1.auto_pwm_min = 255; 443 /* Start monitoring */ 444 value = adm1026_read_value(client, ADM1026_REG_CONFIG1); 445 /* Set MONITOR, clear interrupt acknowledge and s/w reset */ 446 value = (value | CFG1_MONITOR) & (~CFG1_INT_CLEAR & ~CFG1_RESET); 447 dev_dbg(&client->dev, "Setting CONFIG to: 0x%02x\n", value); 448 data->config1 = value; 449 adm1026_write_value(client, ADM1026_REG_CONFIG1, value); 450 451 /* initialize fan_div[] to hardware defaults */ 452 value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3) | 453 (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7) << 8); 454 for (i = 0; i <= 7; ++i) { 455 data->fan_div[i] = DIV_FROM_REG(value & 0x03); 456 value >>= 2; 457 } 458 } 459 460 static void adm1026_print_gpio(struct i2c_client *client) 461 { 462 struct adm1026_data *data = i2c_get_clientdata(client); 463 int i; 464 465 dev_dbg(&client->dev, "GPIO config is:\n"); 466 for (i = 0; i <= 7; ++i) { 467 if (data->config2 & (1 << i)) { 468 dev_dbg(&client->dev, "\t%sGP%s%d\n", 469 data->gpio_config[i] & 0x02 ? "" : "!", 470 data->gpio_config[i] & 0x01 ? "OUT" : "IN", 471 i); 472 } else { 473 dev_dbg(&client->dev, "\tFAN%d\n", i); 474 } 475 } 476 for (i = 8; i <= 15; ++i) { 477 dev_dbg(&client->dev, "\t%sGP%s%d\n", 478 data->gpio_config[i] & 0x02 ? "" : "!", 479 data->gpio_config[i] & 0x01 ? "OUT" : "IN", 480 i); 481 } 482 if (data->config3 & CFG3_GPIO16_ENABLE) { 483 dev_dbg(&client->dev, "\t%sGP%s16\n", 484 data->gpio_config[16] & 0x02 ? "" : "!", 485 data->gpio_config[16] & 0x01 ? "OUT" : "IN"); 486 } else { 487 /* GPIO16 is THERM */ 488 dev_dbg(&client->dev, "\tTHERM\n"); 489 } 490 } 491 492 static void adm1026_fixup_gpio(struct i2c_client *client) 493 { 494 struct adm1026_data *data = i2c_get_clientdata(client); 495 int i; 496 int value; 497 498 /* Make the changes requested. */ 499 /* 500 * We may need to unlock/stop monitoring or soft-reset the 501 * chip before we can make changes. This hasn't been 502 * tested much. FIXME 503 */ 504 505 /* Make outputs */ 506 for (i = 0; i <= 16; ++i) { 507 if (gpio_output[i] >= 0 && gpio_output[i] <= 16) 508 data->gpio_config[gpio_output[i]] |= 0x01; 509 /* if GPIO0-7 is output, it isn't a FAN tach */ 510 if (gpio_output[i] >= 0 && gpio_output[i] <= 7) 511 data->config2 |= 1 << gpio_output[i]; 512 } 513 514 /* Input overrides output */ 515 for (i = 0; i <= 16; ++i) { 516 if (gpio_input[i] >= 0 && gpio_input[i] <= 16) 517 data->gpio_config[gpio_input[i]] &= ~0x01; 518 /* if GPIO0-7 is input, it isn't a FAN tach */ 519 if (gpio_input[i] >= 0 && gpio_input[i] <= 7) 520 data->config2 |= 1 << gpio_input[i]; 521 } 522 523 /* Inverted */ 524 for (i = 0; i <= 16; ++i) { 525 if (gpio_inverted[i] >= 0 && gpio_inverted[i] <= 16) 526 data->gpio_config[gpio_inverted[i]] &= ~0x02; 527 } 528 529 /* Normal overrides inverted */ 530 for (i = 0; i <= 16; ++i) { 531 if (gpio_normal[i] >= 0 && gpio_normal[i] <= 16) 532 data->gpio_config[gpio_normal[i]] |= 0x02; 533 } 534 535 /* Fan overrides input and output */ 536 for (i = 0; i <= 7; ++i) { 537 if (gpio_fan[i] >= 0 && gpio_fan[i] <= 7) 538 data->config2 &= ~(1 << gpio_fan[i]); 539 } 540 541 /* Write new configs to registers */ 542 adm1026_write_value(client, ADM1026_REG_CONFIG2, data->config2); 543 data->config3 = (data->config3 & 0x3f) 544 | ((data->gpio_config[16] & 0x03) << 6); 545 adm1026_write_value(client, ADM1026_REG_CONFIG3, data->config3); 546 for (i = 15, value = 0; i >= 0; --i) { 547 value <<= 2; 548 value |= data->gpio_config[i] & 0x03; 549 if ((i & 0x03) == 0) { 550 adm1026_write_value(client, 551 ADM1026_REG_GPIO_CFG_0_3 + i/4, 552 value); 553 value = 0; 554 } 555 } 556 557 /* Print the new config */ 558 adm1026_print_gpio(client); 559 } 560 561 562 static struct adm1026_data *adm1026_update_device(struct device *dev) 563 { 564 struct i2c_client *client = to_i2c_client(dev); 565 struct adm1026_data *data = i2c_get_clientdata(client); 566 int i; 567 long value, alarms, gpio; 568 569 mutex_lock(&data->update_lock); 570 if (!data->valid 571 || time_after(jiffies, 572 data->last_reading + ADM1026_DATA_INTERVAL)) { 573 /* Things that change quickly */ 574 dev_dbg(&client->dev, "Reading sensor values\n"); 575 for (i = 0; i <= 16; ++i) { 576 data->in[i] = 577 adm1026_read_value(client, ADM1026_REG_IN[i]); 578 } 579 580 for (i = 0; i <= 7; ++i) { 581 data->fan[i] = 582 adm1026_read_value(client, ADM1026_REG_FAN(i)); 583 } 584 585 for (i = 0; i <= 2; ++i) { 586 /* 587 * NOTE: temp[] is s8 and we assume 2's complement 588 * "conversion" in the assignment 589 */ 590 data->temp[i] = 591 adm1026_read_value(client, ADM1026_REG_TEMP[i]); 592 } 593 594 data->pwm1.pwm = adm1026_read_value(client, 595 ADM1026_REG_PWM); 596 data->analog_out = adm1026_read_value(client, 597 ADM1026_REG_DAC); 598 /* GPIO16 is MSbit of alarms, move it to gpio */ 599 alarms = adm1026_read_value(client, ADM1026_REG_STATUS4); 600 gpio = alarms & 0x80 ? 0x0100 : 0; /* GPIO16 */ 601 alarms &= 0x7f; 602 alarms <<= 8; 603 alarms |= adm1026_read_value(client, ADM1026_REG_STATUS3); 604 alarms <<= 8; 605 alarms |= adm1026_read_value(client, ADM1026_REG_STATUS2); 606 alarms <<= 8; 607 alarms |= adm1026_read_value(client, ADM1026_REG_STATUS1); 608 data->alarms = alarms; 609 610 /* Read the GPIO values */ 611 gpio |= adm1026_read_value(client, 612 ADM1026_REG_GPIO_STATUS_8_15); 613 gpio <<= 8; 614 gpio |= adm1026_read_value(client, 615 ADM1026_REG_GPIO_STATUS_0_7); 616 data->gpio = gpio; 617 618 data->last_reading = jiffies; 619 } /* last_reading */ 620 621 if (!data->valid || 622 time_after(jiffies, data->last_config + ADM1026_CONFIG_INTERVAL)) { 623 /* Things that don't change often */ 624 dev_dbg(&client->dev, "Reading config values\n"); 625 for (i = 0; i <= 16; ++i) { 626 data->in_min[i] = adm1026_read_value(client, 627 ADM1026_REG_IN_MIN[i]); 628 data->in_max[i] = adm1026_read_value(client, 629 ADM1026_REG_IN_MAX[i]); 630 } 631 632 value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3) 633 | (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7) 634 << 8); 635 for (i = 0; i <= 7; ++i) { 636 data->fan_min[i] = adm1026_read_value(client, 637 ADM1026_REG_FAN_MIN(i)); 638 data->fan_div[i] = DIV_FROM_REG(value & 0x03); 639 value >>= 2; 640 } 641 642 for (i = 0; i <= 2; ++i) { 643 /* 644 * NOTE: temp_xxx[] are s8 and we assume 2's 645 * complement "conversion" in the assignment 646 */ 647 data->temp_min[i] = adm1026_read_value(client, 648 ADM1026_REG_TEMP_MIN[i]); 649 data->temp_max[i] = adm1026_read_value(client, 650 ADM1026_REG_TEMP_MAX[i]); 651 data->temp_tmin[i] = adm1026_read_value(client, 652 ADM1026_REG_TEMP_TMIN[i]); 653 data->temp_crit[i] = adm1026_read_value(client, 654 ADM1026_REG_TEMP_THERM[i]); 655 data->temp_offset[i] = adm1026_read_value(client, 656 ADM1026_REG_TEMP_OFFSET[i]); 657 } 658 659 /* Read the STATUS/alarm masks */ 660 alarms = adm1026_read_value(client, ADM1026_REG_MASK4); 661 gpio = alarms & 0x80 ? 0x0100 : 0; /* GPIO16 */ 662 alarms = (alarms & 0x7f) << 8; 663 alarms |= adm1026_read_value(client, ADM1026_REG_MASK3); 664 alarms <<= 8; 665 alarms |= adm1026_read_value(client, ADM1026_REG_MASK2); 666 alarms <<= 8; 667 alarms |= adm1026_read_value(client, ADM1026_REG_MASK1); 668 data->alarm_mask = alarms; 669 670 /* Read the GPIO values */ 671 gpio |= adm1026_read_value(client, 672 ADM1026_REG_GPIO_MASK_8_15); 673 gpio <<= 8; 674 gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_0_7); 675 data->gpio_mask = gpio; 676 677 /* Read various values from CONFIG1 */ 678 data->config1 = adm1026_read_value(client, 679 ADM1026_REG_CONFIG1); 680 if (data->config1 & CFG1_PWM_AFC) { 681 data->pwm1.enable = 2; 682 data->pwm1.auto_pwm_min = 683 PWM_MIN_FROM_REG(data->pwm1.pwm); 684 } 685 /* Read the GPIO config */ 686 data->config2 = adm1026_read_value(client, 687 ADM1026_REG_CONFIG2); 688 data->config3 = adm1026_read_value(client, 689 ADM1026_REG_CONFIG3); 690 data->gpio_config[16] = (data->config3 >> 6) & 0x03; 691 692 value = 0; 693 for (i = 0; i <= 15; ++i) { 694 if ((i & 0x03) == 0) { 695 value = adm1026_read_value(client, 696 ADM1026_REG_GPIO_CFG_0_3 + i/4); 697 } 698 data->gpio_config[i] = value & 0x03; 699 value >>= 2; 700 } 701 702 data->last_config = jiffies; 703 } /* last_config */ 704 705 data->valid = 1; 706 mutex_unlock(&data->update_lock); 707 return data; 708 } 709 710 static ssize_t show_in(struct device *dev, struct device_attribute *attr, 711 char *buf) 712 { 713 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 714 int nr = sensor_attr->index; 715 struct adm1026_data *data = adm1026_update_device(dev); 716 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in[nr])); 717 } 718 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr, 719 char *buf) 720 { 721 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 722 int nr = sensor_attr->index; 723 struct adm1026_data *data = adm1026_update_device(dev); 724 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr])); 725 } 726 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr, 727 const char *buf, size_t count) 728 { 729 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 730 int nr = sensor_attr->index; 731 struct i2c_client *client = to_i2c_client(dev); 732 struct adm1026_data *data = i2c_get_clientdata(client); 733 long val; 734 int err; 735 736 err = kstrtol(buf, 10, &val); 737 if (err) 738 return err; 739 740 mutex_lock(&data->update_lock); 741 data->in_min[nr] = INS_TO_REG(nr, val); 742 adm1026_write_value(client, ADM1026_REG_IN_MIN[nr], data->in_min[nr]); 743 mutex_unlock(&data->update_lock); 744 return count; 745 } 746 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr, 747 char *buf) 748 { 749 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 750 int nr = sensor_attr->index; 751 struct adm1026_data *data = adm1026_update_device(dev); 752 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr])); 753 } 754 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr, 755 const char *buf, size_t count) 756 { 757 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 758 int nr = sensor_attr->index; 759 struct i2c_client *client = to_i2c_client(dev); 760 struct adm1026_data *data = i2c_get_clientdata(client); 761 long val; 762 int err; 763 764 err = kstrtol(buf, 10, &val); 765 if (err) 766 return err; 767 768 mutex_lock(&data->update_lock); 769 data->in_max[nr] = INS_TO_REG(nr, val); 770 adm1026_write_value(client, ADM1026_REG_IN_MAX[nr], data->in_max[nr]); 771 mutex_unlock(&data->update_lock); 772 return count; 773 } 774 775 #define in_reg(offset) \ 776 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in, \ 777 NULL, offset); \ 778 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 779 show_in_min, set_in_min, offset); \ 780 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 781 show_in_max, set_in_max, offset); 782 783 784 in_reg(0); 785 in_reg(1); 786 in_reg(2); 787 in_reg(3); 788 in_reg(4); 789 in_reg(5); 790 in_reg(6); 791 in_reg(7); 792 in_reg(8); 793 in_reg(9); 794 in_reg(10); 795 in_reg(11); 796 in_reg(12); 797 in_reg(13); 798 in_reg(14); 799 in_reg(15); 800 801 static ssize_t show_in16(struct device *dev, struct device_attribute *attr, 802 char *buf) 803 { 804 struct adm1026_data *data = adm1026_update_device(dev); 805 return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in[16]) - 806 NEG12_OFFSET); 807 } 808 static ssize_t show_in16_min(struct device *dev, struct device_attribute *attr, 809 char *buf) 810 { 811 struct adm1026_data *data = adm1026_update_device(dev); 812 return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in_min[16]) 813 - NEG12_OFFSET); 814 } 815 static ssize_t set_in16_min(struct device *dev, struct device_attribute *attr, 816 const char *buf, size_t count) 817 { 818 struct i2c_client *client = to_i2c_client(dev); 819 struct adm1026_data *data = i2c_get_clientdata(client); 820 long val; 821 int err; 822 823 err = kstrtol(buf, 10, &val); 824 if (err) 825 return err; 826 827 mutex_lock(&data->update_lock); 828 data->in_min[16] = INS_TO_REG(16, val + NEG12_OFFSET); 829 adm1026_write_value(client, ADM1026_REG_IN_MIN[16], data->in_min[16]); 830 mutex_unlock(&data->update_lock); 831 return count; 832 } 833 static ssize_t show_in16_max(struct device *dev, struct device_attribute *attr, 834 char *buf) 835 { 836 struct adm1026_data *data = adm1026_update_device(dev); 837 return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in_max[16]) 838 - NEG12_OFFSET); 839 } 840 static ssize_t set_in16_max(struct device *dev, struct device_attribute *attr, 841 const char *buf, size_t count) 842 { 843 struct i2c_client *client = to_i2c_client(dev); 844 struct adm1026_data *data = i2c_get_clientdata(client); 845 long val; 846 int err; 847 848 err = kstrtol(buf, 10, &val); 849 if (err) 850 return err; 851 852 mutex_lock(&data->update_lock); 853 data->in_max[16] = INS_TO_REG(16, val+NEG12_OFFSET); 854 adm1026_write_value(client, ADM1026_REG_IN_MAX[16], data->in_max[16]); 855 mutex_unlock(&data->update_lock); 856 return count; 857 } 858 859 static SENSOR_DEVICE_ATTR(in16_input, S_IRUGO, show_in16, NULL, 16); 860 static SENSOR_DEVICE_ATTR(in16_min, S_IRUGO | S_IWUSR, show_in16_min, 861 set_in16_min, 16); 862 static SENSOR_DEVICE_ATTR(in16_max, S_IRUGO | S_IWUSR, show_in16_max, 863 set_in16_max, 16); 864 865 866 /* Now add fan read/write functions */ 867 868 static ssize_t show_fan(struct device *dev, struct device_attribute *attr, 869 char *buf) 870 { 871 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 872 int nr = sensor_attr->index; 873 struct adm1026_data *data = adm1026_update_device(dev); 874 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr], 875 data->fan_div[nr])); 876 } 877 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr, 878 char *buf) 879 { 880 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 881 int nr = sensor_attr->index; 882 struct adm1026_data *data = adm1026_update_device(dev); 883 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr], 884 data->fan_div[nr])); 885 } 886 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, 887 const char *buf, size_t count) 888 { 889 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 890 int nr = sensor_attr->index; 891 struct i2c_client *client = to_i2c_client(dev); 892 struct adm1026_data *data = i2c_get_clientdata(client); 893 long val; 894 int err; 895 896 err = kstrtol(buf, 10, &val); 897 if (err) 898 return err; 899 900 mutex_lock(&data->update_lock); 901 data->fan_min[nr] = FAN_TO_REG(val, data->fan_div[nr]); 902 adm1026_write_value(client, ADM1026_REG_FAN_MIN(nr), 903 data->fan_min[nr]); 904 mutex_unlock(&data->update_lock); 905 return count; 906 } 907 908 #define fan_offset(offset) \ 909 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan, NULL, \ 910 offset - 1); \ 911 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 912 show_fan_min, set_fan_min, offset - 1); 913 914 fan_offset(1); 915 fan_offset(2); 916 fan_offset(3); 917 fan_offset(4); 918 fan_offset(5); 919 fan_offset(6); 920 fan_offset(7); 921 fan_offset(8); 922 923 /* Adjust fan_min to account for new fan divisor */ 924 static void fixup_fan_min(struct device *dev, int fan, int old_div) 925 { 926 struct i2c_client *client = to_i2c_client(dev); 927 struct adm1026_data *data = i2c_get_clientdata(client); 928 int new_min; 929 int new_div = data->fan_div[fan]; 930 931 /* 0 and 0xff are special. Don't adjust them */ 932 if (data->fan_min[fan] == 0 || data->fan_min[fan] == 0xff) 933 return; 934 935 new_min = data->fan_min[fan] * old_div / new_div; 936 new_min = clamp_val(new_min, 1, 254); 937 data->fan_min[fan] = new_min; 938 adm1026_write_value(client, ADM1026_REG_FAN_MIN(fan), new_min); 939 } 940 941 /* Now add fan_div read/write functions */ 942 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr, 943 char *buf) 944 { 945 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 946 int nr = sensor_attr->index; 947 struct adm1026_data *data = adm1026_update_device(dev); 948 return sprintf(buf, "%d\n", data->fan_div[nr]); 949 } 950 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 951 const char *buf, size_t count) 952 { 953 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 954 int nr = sensor_attr->index; 955 struct i2c_client *client = to_i2c_client(dev); 956 struct adm1026_data *data = i2c_get_clientdata(client); 957 long val; 958 int orig_div, new_div; 959 int err; 960 961 err = kstrtol(buf, 10, &val); 962 if (err) 963 return err; 964 965 new_div = DIV_TO_REG(val); 966 967 mutex_lock(&data->update_lock); 968 orig_div = data->fan_div[nr]; 969 data->fan_div[nr] = DIV_FROM_REG(new_div); 970 971 if (nr < 4) { /* 0 <= nr < 4 */ 972 adm1026_write_value(client, ADM1026_REG_FAN_DIV_0_3, 973 (DIV_TO_REG(data->fan_div[0]) << 0) | 974 (DIV_TO_REG(data->fan_div[1]) << 2) | 975 (DIV_TO_REG(data->fan_div[2]) << 4) | 976 (DIV_TO_REG(data->fan_div[3]) << 6)); 977 } else { /* 3 < nr < 8 */ 978 adm1026_write_value(client, ADM1026_REG_FAN_DIV_4_7, 979 (DIV_TO_REG(data->fan_div[4]) << 0) | 980 (DIV_TO_REG(data->fan_div[5]) << 2) | 981 (DIV_TO_REG(data->fan_div[6]) << 4) | 982 (DIV_TO_REG(data->fan_div[7]) << 6)); 983 } 984 985 if (data->fan_div[nr] != orig_div) 986 fixup_fan_min(dev, nr, orig_div); 987 988 mutex_unlock(&data->update_lock); 989 return count; 990 } 991 992 #define fan_offset_div(offset) \ 993 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 994 show_fan_div, set_fan_div, offset - 1); 995 996 fan_offset_div(1); 997 fan_offset_div(2); 998 fan_offset_div(3); 999 fan_offset_div(4); 1000 fan_offset_div(5); 1001 fan_offset_div(6); 1002 fan_offset_div(7); 1003 fan_offset_div(8); 1004 1005 /* Temps */ 1006 static ssize_t show_temp(struct device *dev, struct device_attribute *attr, 1007 char *buf) 1008 { 1009 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1010 int nr = sensor_attr->index; 1011 struct adm1026_data *data = adm1026_update_device(dev); 1012 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr])); 1013 } 1014 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr, 1015 char *buf) 1016 { 1017 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1018 int nr = sensor_attr->index; 1019 struct adm1026_data *data = adm1026_update_device(dev); 1020 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr])); 1021 } 1022 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, 1023 const char *buf, size_t count) 1024 { 1025 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1026 int nr = sensor_attr->index; 1027 struct i2c_client *client = to_i2c_client(dev); 1028 struct adm1026_data *data = i2c_get_clientdata(client); 1029 long val; 1030 int err; 1031 1032 err = kstrtol(buf, 10, &val); 1033 if (err) 1034 return err; 1035 1036 mutex_lock(&data->update_lock); 1037 data->temp_min[nr] = TEMP_TO_REG(val); 1038 adm1026_write_value(client, ADM1026_REG_TEMP_MIN[nr], 1039 data->temp_min[nr]); 1040 mutex_unlock(&data->update_lock); 1041 return count; 1042 } 1043 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr, 1044 char *buf) 1045 { 1046 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1047 int nr = sensor_attr->index; 1048 struct adm1026_data *data = adm1026_update_device(dev); 1049 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr])); 1050 } 1051 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, 1052 const char *buf, size_t count) 1053 { 1054 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1055 int nr = sensor_attr->index; 1056 struct i2c_client *client = to_i2c_client(dev); 1057 struct adm1026_data *data = i2c_get_clientdata(client); 1058 long val; 1059 int err; 1060 1061 err = kstrtol(buf, 10, &val); 1062 if (err) 1063 return err; 1064 1065 mutex_lock(&data->update_lock); 1066 data->temp_max[nr] = TEMP_TO_REG(val); 1067 adm1026_write_value(client, ADM1026_REG_TEMP_MAX[nr], 1068 data->temp_max[nr]); 1069 mutex_unlock(&data->update_lock); 1070 return count; 1071 } 1072 1073 #define temp_reg(offset) \ 1074 static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp, \ 1075 NULL, offset - 1); \ 1076 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR, \ 1077 show_temp_min, set_temp_min, offset - 1); \ 1078 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR, \ 1079 show_temp_max, set_temp_max, offset - 1); 1080 1081 1082 temp_reg(1); 1083 temp_reg(2); 1084 temp_reg(3); 1085 1086 static ssize_t show_temp_offset(struct device *dev, 1087 struct device_attribute *attr, char *buf) 1088 { 1089 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1090 int nr = sensor_attr->index; 1091 struct adm1026_data *data = adm1026_update_device(dev); 1092 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_offset[nr])); 1093 } 1094 static ssize_t set_temp_offset(struct device *dev, 1095 struct device_attribute *attr, const char *buf, 1096 size_t count) 1097 { 1098 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1099 int nr = sensor_attr->index; 1100 struct i2c_client *client = to_i2c_client(dev); 1101 struct adm1026_data *data = i2c_get_clientdata(client); 1102 long val; 1103 int err; 1104 1105 err = kstrtol(buf, 10, &val); 1106 if (err) 1107 return err; 1108 1109 mutex_lock(&data->update_lock); 1110 data->temp_offset[nr] = TEMP_TO_REG(val); 1111 adm1026_write_value(client, ADM1026_REG_TEMP_OFFSET[nr], 1112 data->temp_offset[nr]); 1113 mutex_unlock(&data->update_lock); 1114 return count; 1115 } 1116 1117 #define temp_offset_reg(offset) \ 1118 static SENSOR_DEVICE_ATTR(temp##offset##_offset, S_IRUGO | S_IWUSR, \ 1119 show_temp_offset, set_temp_offset, offset - 1); 1120 1121 temp_offset_reg(1); 1122 temp_offset_reg(2); 1123 temp_offset_reg(3); 1124 1125 static ssize_t show_temp_auto_point1_temp_hyst(struct device *dev, 1126 struct device_attribute *attr, char *buf) 1127 { 1128 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1129 int nr = sensor_attr->index; 1130 struct adm1026_data *data = adm1026_update_device(dev); 1131 return sprintf(buf, "%d\n", TEMP_FROM_REG( 1132 ADM1026_FAN_ACTIVATION_TEMP_HYST + data->temp_tmin[nr])); 1133 } 1134 static ssize_t show_temp_auto_point2_temp(struct device *dev, 1135 struct device_attribute *attr, char *buf) 1136 { 1137 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1138 int nr = sensor_attr->index; 1139 struct adm1026_data *data = adm1026_update_device(dev); 1140 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr] + 1141 ADM1026_FAN_CONTROL_TEMP_RANGE)); 1142 } 1143 static ssize_t show_temp_auto_point1_temp(struct device *dev, 1144 struct device_attribute *attr, char *buf) 1145 { 1146 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1147 int nr = sensor_attr->index; 1148 struct adm1026_data *data = adm1026_update_device(dev); 1149 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr])); 1150 } 1151 static ssize_t set_temp_auto_point1_temp(struct device *dev, 1152 struct device_attribute *attr, const char *buf, size_t count) 1153 { 1154 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1155 int nr = sensor_attr->index; 1156 struct i2c_client *client = to_i2c_client(dev); 1157 struct adm1026_data *data = i2c_get_clientdata(client); 1158 long val; 1159 int err; 1160 1161 err = kstrtol(buf, 10, &val); 1162 if (err) 1163 return err; 1164 1165 mutex_lock(&data->update_lock); 1166 data->temp_tmin[nr] = TEMP_TO_REG(val); 1167 adm1026_write_value(client, ADM1026_REG_TEMP_TMIN[nr], 1168 data->temp_tmin[nr]); 1169 mutex_unlock(&data->update_lock); 1170 return count; 1171 } 1172 1173 #define temp_auto_point(offset) \ 1174 static SENSOR_DEVICE_ATTR(temp##offset##_auto_point1_temp, \ 1175 S_IRUGO | S_IWUSR, show_temp_auto_point1_temp, \ 1176 set_temp_auto_point1_temp, offset - 1); \ 1177 static SENSOR_DEVICE_ATTR(temp##offset##_auto_point1_temp_hyst, S_IRUGO,\ 1178 show_temp_auto_point1_temp_hyst, NULL, offset - 1); \ 1179 static SENSOR_DEVICE_ATTR(temp##offset##_auto_point2_temp, S_IRUGO, \ 1180 show_temp_auto_point2_temp, NULL, offset - 1); 1181 1182 temp_auto_point(1); 1183 temp_auto_point(2); 1184 temp_auto_point(3); 1185 1186 static ssize_t show_temp_crit_enable(struct device *dev, 1187 struct device_attribute *attr, char *buf) 1188 { 1189 struct adm1026_data *data = adm1026_update_device(dev); 1190 return sprintf(buf, "%d\n", (data->config1 & CFG1_THERM_HOT) >> 4); 1191 } 1192 static ssize_t set_temp_crit_enable(struct device *dev, 1193 struct device_attribute *attr, const char *buf, size_t count) 1194 { 1195 struct i2c_client *client = to_i2c_client(dev); 1196 struct adm1026_data *data = i2c_get_clientdata(client); 1197 unsigned long val; 1198 int err; 1199 1200 err = kstrtoul(buf, 10, &val); 1201 if (err) 1202 return err; 1203 1204 if (val > 1) 1205 return -EINVAL; 1206 1207 mutex_lock(&data->update_lock); 1208 data->config1 = (data->config1 & ~CFG1_THERM_HOT) | (val << 4); 1209 adm1026_write_value(client, ADM1026_REG_CONFIG1, data->config1); 1210 mutex_unlock(&data->update_lock); 1211 1212 return count; 1213 } 1214 1215 #define temp_crit_enable(offset) \ 1216 static DEVICE_ATTR(temp##offset##_crit_enable, S_IRUGO | S_IWUSR, \ 1217 show_temp_crit_enable, set_temp_crit_enable); 1218 1219 temp_crit_enable(1); 1220 temp_crit_enable(2); 1221 temp_crit_enable(3); 1222 1223 static ssize_t show_temp_crit(struct device *dev, 1224 struct device_attribute *attr, char *buf) 1225 { 1226 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1227 int nr = sensor_attr->index; 1228 struct adm1026_data *data = adm1026_update_device(dev); 1229 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr])); 1230 } 1231 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr, 1232 const char *buf, size_t count) 1233 { 1234 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 1235 int nr = sensor_attr->index; 1236 struct i2c_client *client = to_i2c_client(dev); 1237 struct adm1026_data *data = i2c_get_clientdata(client); 1238 long val; 1239 int err; 1240 1241 err = kstrtol(buf, 10, &val); 1242 if (err) 1243 return err; 1244 1245 mutex_lock(&data->update_lock); 1246 data->temp_crit[nr] = TEMP_TO_REG(val); 1247 adm1026_write_value(client, ADM1026_REG_TEMP_THERM[nr], 1248 data->temp_crit[nr]); 1249 mutex_unlock(&data->update_lock); 1250 return count; 1251 } 1252 1253 #define temp_crit_reg(offset) \ 1254 static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR, \ 1255 show_temp_crit, set_temp_crit, offset - 1); 1256 1257 temp_crit_reg(1); 1258 temp_crit_reg(2); 1259 temp_crit_reg(3); 1260 1261 static ssize_t show_analog_out_reg(struct device *dev, 1262 struct device_attribute *attr, char *buf) 1263 { 1264 struct adm1026_data *data = adm1026_update_device(dev); 1265 return sprintf(buf, "%d\n", DAC_FROM_REG(data->analog_out)); 1266 } 1267 static ssize_t set_analog_out_reg(struct device *dev, 1268 struct device_attribute *attr, 1269 const char *buf, size_t count) 1270 { 1271 struct i2c_client *client = to_i2c_client(dev); 1272 struct adm1026_data *data = i2c_get_clientdata(client); 1273 long val; 1274 int err; 1275 1276 err = kstrtol(buf, 10, &val); 1277 if (err) 1278 return err; 1279 1280 mutex_lock(&data->update_lock); 1281 data->analog_out = DAC_TO_REG(val); 1282 adm1026_write_value(client, ADM1026_REG_DAC, data->analog_out); 1283 mutex_unlock(&data->update_lock); 1284 return count; 1285 } 1286 1287 static DEVICE_ATTR(analog_out, S_IRUGO | S_IWUSR, show_analog_out_reg, 1288 set_analog_out_reg); 1289 1290 static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, 1291 char *buf) 1292 { 1293 struct adm1026_data *data = adm1026_update_device(dev); 1294 int vid = (data->gpio >> 11) & 0x1f; 1295 1296 dev_dbg(dev, "Setting VID from GPIO11-15.\n"); 1297 return sprintf(buf, "%d\n", vid_from_reg(vid, data->vrm)); 1298 } 1299 1300 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); 1301 1302 static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr, 1303 char *buf) 1304 { 1305 struct adm1026_data *data = dev_get_drvdata(dev); 1306 return sprintf(buf, "%d\n", data->vrm); 1307 } 1308 1309 static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr, 1310 const char *buf, size_t count) 1311 { 1312 struct adm1026_data *data = dev_get_drvdata(dev); 1313 unsigned long val; 1314 int err; 1315 1316 err = kstrtoul(buf, 10, &val); 1317 if (err) 1318 return err; 1319 1320 data->vrm = val; 1321 return count; 1322 } 1323 1324 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); 1325 1326 static ssize_t show_alarms_reg(struct device *dev, 1327 struct device_attribute *attr, char *buf) 1328 { 1329 struct adm1026_data *data = adm1026_update_device(dev); 1330 return sprintf(buf, "%ld\n", data->alarms); 1331 } 1332 1333 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL); 1334 1335 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 1336 char *buf) 1337 { 1338 struct adm1026_data *data = adm1026_update_device(dev); 1339 int bitnr = to_sensor_dev_attr(attr)->index; 1340 return sprintf(buf, "%ld\n", (data->alarms >> bitnr) & 1); 1341 } 1342 1343 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 0); 1344 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 1); 1345 static SENSOR_DEVICE_ATTR(in9_alarm, S_IRUGO, show_alarm, NULL, 1); 1346 static SENSOR_DEVICE_ATTR(in11_alarm, S_IRUGO, show_alarm, NULL, 2); 1347 static SENSOR_DEVICE_ATTR(in12_alarm, S_IRUGO, show_alarm, NULL, 3); 1348 static SENSOR_DEVICE_ATTR(in13_alarm, S_IRUGO, show_alarm, NULL, 4); 1349 static SENSOR_DEVICE_ATTR(in14_alarm, S_IRUGO, show_alarm, NULL, 5); 1350 static SENSOR_DEVICE_ATTR(in15_alarm, S_IRUGO, show_alarm, NULL, 6); 1351 static SENSOR_DEVICE_ATTR(in16_alarm, S_IRUGO, show_alarm, NULL, 7); 1352 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8); 1353 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9); 1354 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10); 1355 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11); 1356 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12); 1357 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13); 1358 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14); 1359 static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15); 1360 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 16); 1361 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 17); 1362 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 18); 1363 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 19); 1364 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 20); 1365 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL, 21); 1366 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL, 22); 1367 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL, 23); 1368 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 24); 1369 static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 25); 1370 static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 26); 1371 1372 static ssize_t show_alarm_mask(struct device *dev, 1373 struct device_attribute *attr, char *buf) 1374 { 1375 struct adm1026_data *data = adm1026_update_device(dev); 1376 return sprintf(buf, "%ld\n", data->alarm_mask); 1377 } 1378 static ssize_t set_alarm_mask(struct device *dev, struct device_attribute *attr, 1379 const char *buf, size_t count) 1380 { 1381 struct i2c_client *client = to_i2c_client(dev); 1382 struct adm1026_data *data = i2c_get_clientdata(client); 1383 unsigned long mask; 1384 long val; 1385 int err; 1386 1387 err = kstrtol(buf, 10, &val); 1388 if (err) 1389 return err; 1390 1391 mutex_lock(&data->update_lock); 1392 data->alarm_mask = val & 0x7fffffff; 1393 mask = data->alarm_mask 1394 | (data->gpio_mask & 0x10000 ? 0x80000000 : 0); 1395 adm1026_write_value(client, ADM1026_REG_MASK1, 1396 mask & 0xff); 1397 mask >>= 8; 1398 adm1026_write_value(client, ADM1026_REG_MASK2, 1399 mask & 0xff); 1400 mask >>= 8; 1401 adm1026_write_value(client, ADM1026_REG_MASK3, 1402 mask & 0xff); 1403 mask >>= 8; 1404 adm1026_write_value(client, ADM1026_REG_MASK4, 1405 mask & 0xff); 1406 mutex_unlock(&data->update_lock); 1407 return count; 1408 } 1409 1410 static DEVICE_ATTR(alarm_mask, S_IRUGO | S_IWUSR, show_alarm_mask, 1411 set_alarm_mask); 1412 1413 1414 static ssize_t show_gpio(struct device *dev, struct device_attribute *attr, 1415 char *buf) 1416 { 1417 struct adm1026_data *data = adm1026_update_device(dev); 1418 return sprintf(buf, "%ld\n", data->gpio); 1419 } 1420 static ssize_t set_gpio(struct device *dev, struct device_attribute *attr, 1421 const char *buf, size_t count) 1422 { 1423 struct i2c_client *client = to_i2c_client(dev); 1424 struct adm1026_data *data = i2c_get_clientdata(client); 1425 long gpio; 1426 long val; 1427 int err; 1428 1429 err = kstrtol(buf, 10, &val); 1430 if (err) 1431 return err; 1432 1433 mutex_lock(&data->update_lock); 1434 data->gpio = val & 0x1ffff; 1435 gpio = data->gpio; 1436 adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_0_7, gpio & 0xff); 1437 gpio >>= 8; 1438 adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_8_15, gpio & 0xff); 1439 gpio = ((gpio >> 1) & 0x80) | (data->alarms >> 24 & 0x7f); 1440 adm1026_write_value(client, ADM1026_REG_STATUS4, gpio & 0xff); 1441 mutex_unlock(&data->update_lock); 1442 return count; 1443 } 1444 1445 static DEVICE_ATTR(gpio, S_IRUGO | S_IWUSR, show_gpio, set_gpio); 1446 1447 static ssize_t show_gpio_mask(struct device *dev, struct device_attribute *attr, 1448 char *buf) 1449 { 1450 struct adm1026_data *data = adm1026_update_device(dev); 1451 return sprintf(buf, "%ld\n", data->gpio_mask); 1452 } 1453 static ssize_t set_gpio_mask(struct device *dev, struct device_attribute *attr, 1454 const char *buf, size_t count) 1455 { 1456 struct i2c_client *client = to_i2c_client(dev); 1457 struct adm1026_data *data = i2c_get_clientdata(client); 1458 long mask; 1459 long val; 1460 int err; 1461 1462 err = kstrtol(buf, 10, &val); 1463 if (err) 1464 return err; 1465 1466 mutex_lock(&data->update_lock); 1467 data->gpio_mask = val & 0x1ffff; 1468 mask = data->gpio_mask; 1469 adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7, mask & 0xff); 1470 mask >>= 8; 1471 adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15, mask & 0xff); 1472 mask = ((mask >> 1) & 0x80) | (data->alarm_mask >> 24 & 0x7f); 1473 adm1026_write_value(client, ADM1026_REG_MASK1, mask & 0xff); 1474 mutex_unlock(&data->update_lock); 1475 return count; 1476 } 1477 1478 static DEVICE_ATTR(gpio_mask, S_IRUGO | S_IWUSR, show_gpio_mask, set_gpio_mask); 1479 1480 static ssize_t show_pwm_reg(struct device *dev, struct device_attribute *attr, 1481 char *buf) 1482 { 1483 struct adm1026_data *data = adm1026_update_device(dev); 1484 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm1.pwm)); 1485 } 1486 1487 static ssize_t set_pwm_reg(struct device *dev, struct device_attribute *attr, 1488 const char *buf, size_t count) 1489 { 1490 struct i2c_client *client = to_i2c_client(dev); 1491 struct adm1026_data *data = i2c_get_clientdata(client); 1492 1493 if (data->pwm1.enable == 1) { 1494 long val; 1495 int err; 1496 1497 err = kstrtol(buf, 10, &val); 1498 if (err) 1499 return err; 1500 1501 mutex_lock(&data->update_lock); 1502 data->pwm1.pwm = PWM_TO_REG(val); 1503 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm); 1504 mutex_unlock(&data->update_lock); 1505 } 1506 return count; 1507 } 1508 1509 static ssize_t show_auto_pwm_min(struct device *dev, 1510 struct device_attribute *attr, char *buf) 1511 { 1512 struct adm1026_data *data = adm1026_update_device(dev); 1513 return sprintf(buf, "%d\n", data->pwm1.auto_pwm_min); 1514 } 1515 1516 static ssize_t set_auto_pwm_min(struct device *dev, 1517 struct device_attribute *attr, const char *buf, 1518 size_t count) 1519 { 1520 struct i2c_client *client = to_i2c_client(dev); 1521 struct adm1026_data *data = i2c_get_clientdata(client); 1522 unsigned long val; 1523 int err; 1524 1525 err = kstrtoul(buf, 10, &val); 1526 if (err) 1527 return err; 1528 1529 mutex_lock(&data->update_lock); 1530 data->pwm1.auto_pwm_min = clamp_val(val, 0, 255); 1531 if (data->pwm1.enable == 2) { /* apply immediately */ 1532 data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) | 1533 PWM_MIN_TO_REG(data->pwm1.auto_pwm_min)); 1534 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm); 1535 } 1536 mutex_unlock(&data->update_lock); 1537 return count; 1538 } 1539 1540 static ssize_t show_auto_pwm_max(struct device *dev, 1541 struct device_attribute *attr, char *buf) 1542 { 1543 return sprintf(buf, "%d\n", ADM1026_PWM_MAX); 1544 } 1545 1546 static ssize_t show_pwm_enable(struct device *dev, 1547 struct device_attribute *attr, char *buf) 1548 { 1549 struct adm1026_data *data = adm1026_update_device(dev); 1550 return sprintf(buf, "%d\n", data->pwm1.enable); 1551 } 1552 1553 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr, 1554 const char *buf, size_t count) 1555 { 1556 struct i2c_client *client = to_i2c_client(dev); 1557 struct adm1026_data *data = i2c_get_clientdata(client); 1558 int old_enable; 1559 unsigned long val; 1560 int err; 1561 1562 err = kstrtoul(buf, 10, &val); 1563 if (err) 1564 return err; 1565 1566 if (val >= 3) 1567 return -EINVAL; 1568 1569 mutex_lock(&data->update_lock); 1570 old_enable = data->pwm1.enable; 1571 data->pwm1.enable = val; 1572 data->config1 = (data->config1 & ~CFG1_PWM_AFC) 1573 | ((val == 2) ? CFG1_PWM_AFC : 0); 1574 adm1026_write_value(client, ADM1026_REG_CONFIG1, data->config1); 1575 if (val == 2) { /* apply pwm1_auto_pwm_min to pwm1 */ 1576 data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) | 1577 PWM_MIN_TO_REG(data->pwm1.auto_pwm_min)); 1578 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm); 1579 } else if (!((old_enable == 1) && (val == 1))) { 1580 /* set pwm to safe value */ 1581 data->pwm1.pwm = 255; 1582 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm); 1583 } 1584 mutex_unlock(&data->update_lock); 1585 1586 return count; 1587 } 1588 1589 /* enable PWM fan control */ 1590 static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm_reg, set_pwm_reg); 1591 static DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm_reg, set_pwm_reg); 1592 static DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, show_pwm_reg, set_pwm_reg); 1593 static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable, 1594 set_pwm_enable); 1595 static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR, show_pwm_enable, 1596 set_pwm_enable); 1597 static DEVICE_ATTR(pwm3_enable, S_IRUGO | S_IWUSR, show_pwm_enable, 1598 set_pwm_enable); 1599 static DEVICE_ATTR(temp1_auto_point1_pwm, S_IRUGO | S_IWUSR, 1600 show_auto_pwm_min, set_auto_pwm_min); 1601 static DEVICE_ATTR(temp2_auto_point1_pwm, S_IRUGO | S_IWUSR, 1602 show_auto_pwm_min, set_auto_pwm_min); 1603 static DEVICE_ATTR(temp3_auto_point1_pwm, S_IRUGO | S_IWUSR, 1604 show_auto_pwm_min, set_auto_pwm_min); 1605 1606 static DEVICE_ATTR(temp1_auto_point2_pwm, S_IRUGO, show_auto_pwm_max, NULL); 1607 static DEVICE_ATTR(temp2_auto_point2_pwm, S_IRUGO, show_auto_pwm_max, NULL); 1608 static DEVICE_ATTR(temp3_auto_point2_pwm, S_IRUGO, show_auto_pwm_max, NULL); 1609 1610 static struct attribute *adm1026_attributes[] = { 1611 &sensor_dev_attr_in0_input.dev_attr.attr, 1612 &sensor_dev_attr_in0_max.dev_attr.attr, 1613 &sensor_dev_attr_in0_min.dev_attr.attr, 1614 &sensor_dev_attr_in0_alarm.dev_attr.attr, 1615 &sensor_dev_attr_in1_input.dev_attr.attr, 1616 &sensor_dev_attr_in1_max.dev_attr.attr, 1617 &sensor_dev_attr_in1_min.dev_attr.attr, 1618 &sensor_dev_attr_in1_alarm.dev_attr.attr, 1619 &sensor_dev_attr_in2_input.dev_attr.attr, 1620 &sensor_dev_attr_in2_max.dev_attr.attr, 1621 &sensor_dev_attr_in2_min.dev_attr.attr, 1622 &sensor_dev_attr_in2_alarm.dev_attr.attr, 1623 &sensor_dev_attr_in3_input.dev_attr.attr, 1624 &sensor_dev_attr_in3_max.dev_attr.attr, 1625 &sensor_dev_attr_in3_min.dev_attr.attr, 1626 &sensor_dev_attr_in3_alarm.dev_attr.attr, 1627 &sensor_dev_attr_in4_input.dev_attr.attr, 1628 &sensor_dev_attr_in4_max.dev_attr.attr, 1629 &sensor_dev_attr_in4_min.dev_attr.attr, 1630 &sensor_dev_attr_in4_alarm.dev_attr.attr, 1631 &sensor_dev_attr_in5_input.dev_attr.attr, 1632 &sensor_dev_attr_in5_max.dev_attr.attr, 1633 &sensor_dev_attr_in5_min.dev_attr.attr, 1634 &sensor_dev_attr_in5_alarm.dev_attr.attr, 1635 &sensor_dev_attr_in6_input.dev_attr.attr, 1636 &sensor_dev_attr_in6_max.dev_attr.attr, 1637 &sensor_dev_attr_in6_min.dev_attr.attr, 1638 &sensor_dev_attr_in6_alarm.dev_attr.attr, 1639 &sensor_dev_attr_in7_input.dev_attr.attr, 1640 &sensor_dev_attr_in7_max.dev_attr.attr, 1641 &sensor_dev_attr_in7_min.dev_attr.attr, 1642 &sensor_dev_attr_in7_alarm.dev_attr.attr, 1643 &sensor_dev_attr_in10_input.dev_attr.attr, 1644 &sensor_dev_attr_in10_max.dev_attr.attr, 1645 &sensor_dev_attr_in10_min.dev_attr.attr, 1646 &sensor_dev_attr_in10_alarm.dev_attr.attr, 1647 &sensor_dev_attr_in11_input.dev_attr.attr, 1648 &sensor_dev_attr_in11_max.dev_attr.attr, 1649 &sensor_dev_attr_in11_min.dev_attr.attr, 1650 &sensor_dev_attr_in11_alarm.dev_attr.attr, 1651 &sensor_dev_attr_in12_input.dev_attr.attr, 1652 &sensor_dev_attr_in12_max.dev_attr.attr, 1653 &sensor_dev_attr_in12_min.dev_attr.attr, 1654 &sensor_dev_attr_in12_alarm.dev_attr.attr, 1655 &sensor_dev_attr_in13_input.dev_attr.attr, 1656 &sensor_dev_attr_in13_max.dev_attr.attr, 1657 &sensor_dev_attr_in13_min.dev_attr.attr, 1658 &sensor_dev_attr_in13_alarm.dev_attr.attr, 1659 &sensor_dev_attr_in14_input.dev_attr.attr, 1660 &sensor_dev_attr_in14_max.dev_attr.attr, 1661 &sensor_dev_attr_in14_min.dev_attr.attr, 1662 &sensor_dev_attr_in14_alarm.dev_attr.attr, 1663 &sensor_dev_attr_in15_input.dev_attr.attr, 1664 &sensor_dev_attr_in15_max.dev_attr.attr, 1665 &sensor_dev_attr_in15_min.dev_attr.attr, 1666 &sensor_dev_attr_in15_alarm.dev_attr.attr, 1667 &sensor_dev_attr_in16_input.dev_attr.attr, 1668 &sensor_dev_attr_in16_max.dev_attr.attr, 1669 &sensor_dev_attr_in16_min.dev_attr.attr, 1670 &sensor_dev_attr_in16_alarm.dev_attr.attr, 1671 &sensor_dev_attr_fan1_input.dev_attr.attr, 1672 &sensor_dev_attr_fan1_div.dev_attr.attr, 1673 &sensor_dev_attr_fan1_min.dev_attr.attr, 1674 &sensor_dev_attr_fan1_alarm.dev_attr.attr, 1675 &sensor_dev_attr_fan2_input.dev_attr.attr, 1676 &sensor_dev_attr_fan2_div.dev_attr.attr, 1677 &sensor_dev_attr_fan2_min.dev_attr.attr, 1678 &sensor_dev_attr_fan2_alarm.dev_attr.attr, 1679 &sensor_dev_attr_fan3_input.dev_attr.attr, 1680 &sensor_dev_attr_fan3_div.dev_attr.attr, 1681 &sensor_dev_attr_fan3_min.dev_attr.attr, 1682 &sensor_dev_attr_fan3_alarm.dev_attr.attr, 1683 &sensor_dev_attr_fan4_input.dev_attr.attr, 1684 &sensor_dev_attr_fan4_div.dev_attr.attr, 1685 &sensor_dev_attr_fan4_min.dev_attr.attr, 1686 &sensor_dev_attr_fan4_alarm.dev_attr.attr, 1687 &sensor_dev_attr_fan5_input.dev_attr.attr, 1688 &sensor_dev_attr_fan5_div.dev_attr.attr, 1689 &sensor_dev_attr_fan5_min.dev_attr.attr, 1690 &sensor_dev_attr_fan5_alarm.dev_attr.attr, 1691 &sensor_dev_attr_fan6_input.dev_attr.attr, 1692 &sensor_dev_attr_fan6_div.dev_attr.attr, 1693 &sensor_dev_attr_fan6_min.dev_attr.attr, 1694 &sensor_dev_attr_fan6_alarm.dev_attr.attr, 1695 &sensor_dev_attr_fan7_input.dev_attr.attr, 1696 &sensor_dev_attr_fan7_div.dev_attr.attr, 1697 &sensor_dev_attr_fan7_min.dev_attr.attr, 1698 &sensor_dev_attr_fan7_alarm.dev_attr.attr, 1699 &sensor_dev_attr_fan8_input.dev_attr.attr, 1700 &sensor_dev_attr_fan8_div.dev_attr.attr, 1701 &sensor_dev_attr_fan8_min.dev_attr.attr, 1702 &sensor_dev_attr_fan8_alarm.dev_attr.attr, 1703 &sensor_dev_attr_temp1_input.dev_attr.attr, 1704 &sensor_dev_attr_temp1_max.dev_attr.attr, 1705 &sensor_dev_attr_temp1_min.dev_attr.attr, 1706 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 1707 &sensor_dev_attr_temp2_input.dev_attr.attr, 1708 &sensor_dev_attr_temp2_max.dev_attr.attr, 1709 &sensor_dev_attr_temp2_min.dev_attr.attr, 1710 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 1711 &sensor_dev_attr_temp1_offset.dev_attr.attr, 1712 &sensor_dev_attr_temp2_offset.dev_attr.attr, 1713 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr, 1714 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr, 1715 &sensor_dev_attr_temp1_auto_point1_temp_hyst.dev_attr.attr, 1716 &sensor_dev_attr_temp2_auto_point1_temp_hyst.dev_attr.attr, 1717 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr, 1718 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr, 1719 &sensor_dev_attr_temp1_crit.dev_attr.attr, 1720 &sensor_dev_attr_temp2_crit.dev_attr.attr, 1721 &dev_attr_temp1_crit_enable.attr, 1722 &dev_attr_temp2_crit_enable.attr, 1723 &dev_attr_cpu0_vid.attr, 1724 &dev_attr_vrm.attr, 1725 &dev_attr_alarms.attr, 1726 &dev_attr_alarm_mask.attr, 1727 &dev_attr_gpio.attr, 1728 &dev_attr_gpio_mask.attr, 1729 &dev_attr_pwm1.attr, 1730 &dev_attr_pwm2.attr, 1731 &dev_attr_pwm3.attr, 1732 &dev_attr_pwm1_enable.attr, 1733 &dev_attr_pwm2_enable.attr, 1734 &dev_attr_pwm3_enable.attr, 1735 &dev_attr_temp1_auto_point1_pwm.attr, 1736 &dev_attr_temp2_auto_point1_pwm.attr, 1737 &dev_attr_temp1_auto_point2_pwm.attr, 1738 &dev_attr_temp2_auto_point2_pwm.attr, 1739 &dev_attr_analog_out.attr, 1740 NULL 1741 }; 1742 1743 static const struct attribute_group adm1026_group = { 1744 .attrs = adm1026_attributes, 1745 }; 1746 1747 static struct attribute *adm1026_attributes_temp3[] = { 1748 &sensor_dev_attr_temp3_input.dev_attr.attr, 1749 &sensor_dev_attr_temp3_max.dev_attr.attr, 1750 &sensor_dev_attr_temp3_min.dev_attr.attr, 1751 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 1752 &sensor_dev_attr_temp3_offset.dev_attr.attr, 1753 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr, 1754 &sensor_dev_attr_temp3_auto_point1_temp_hyst.dev_attr.attr, 1755 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr, 1756 &sensor_dev_attr_temp3_crit.dev_attr.attr, 1757 &dev_attr_temp3_crit_enable.attr, 1758 &dev_attr_temp3_auto_point1_pwm.attr, 1759 &dev_attr_temp3_auto_point2_pwm.attr, 1760 NULL 1761 }; 1762 1763 static const struct attribute_group adm1026_group_temp3 = { 1764 .attrs = adm1026_attributes_temp3, 1765 }; 1766 1767 static struct attribute *adm1026_attributes_in8_9[] = { 1768 &sensor_dev_attr_in8_input.dev_attr.attr, 1769 &sensor_dev_attr_in8_max.dev_attr.attr, 1770 &sensor_dev_attr_in8_min.dev_attr.attr, 1771 &sensor_dev_attr_in8_alarm.dev_attr.attr, 1772 &sensor_dev_attr_in9_input.dev_attr.attr, 1773 &sensor_dev_attr_in9_max.dev_attr.attr, 1774 &sensor_dev_attr_in9_min.dev_attr.attr, 1775 &sensor_dev_attr_in9_alarm.dev_attr.attr, 1776 NULL 1777 }; 1778 1779 static const struct attribute_group adm1026_group_in8_9 = { 1780 .attrs = adm1026_attributes_in8_9, 1781 }; 1782 1783 /* Return 0 if detection is successful, -ENODEV otherwise */ 1784 static int adm1026_detect(struct i2c_client *client, 1785 struct i2c_board_info *info) 1786 { 1787 struct i2c_adapter *adapter = client->adapter; 1788 int address = client->addr; 1789 int company, verstep; 1790 1791 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 1792 /* We need to be able to do byte I/O */ 1793 return -ENODEV; 1794 } 1795 1796 /* Now, we do the remaining detection. */ 1797 1798 company = adm1026_read_value(client, ADM1026_REG_COMPANY); 1799 verstep = adm1026_read_value(client, ADM1026_REG_VERSTEP); 1800 1801 dev_dbg(&adapter->dev, 1802 "Detecting device at %d,0x%02x with COMPANY: 0x%02x and VERSTEP: 0x%02x\n", 1803 i2c_adapter_id(client->adapter), client->addr, 1804 company, verstep); 1805 1806 /* Determine the chip type. */ 1807 dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x...\n", 1808 i2c_adapter_id(adapter), address); 1809 if (company == ADM1026_COMPANY_ANALOG_DEV 1810 && verstep == ADM1026_VERSTEP_ADM1026) { 1811 /* Analog Devices ADM1026 */ 1812 } else if (company == ADM1026_COMPANY_ANALOG_DEV 1813 && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) { 1814 dev_err(&adapter->dev, 1815 "Unrecognized stepping 0x%02x. Defaulting to ADM1026.\n", 1816 verstep); 1817 } else if ((verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) { 1818 dev_err(&adapter->dev, 1819 "Found version/stepping 0x%02x. Assuming generic ADM1026.\n", 1820 verstep); 1821 } else { 1822 dev_dbg(&adapter->dev, "Autodetection failed\n"); 1823 /* Not an ADM1026... */ 1824 return -ENODEV; 1825 } 1826 1827 strlcpy(info->type, "adm1026", I2C_NAME_SIZE); 1828 1829 return 0; 1830 } 1831 1832 static int adm1026_probe(struct i2c_client *client, 1833 const struct i2c_device_id *id) 1834 { 1835 struct adm1026_data *data; 1836 int err; 1837 1838 data = devm_kzalloc(&client->dev, sizeof(struct adm1026_data), 1839 GFP_KERNEL); 1840 if (!data) 1841 return -ENOMEM; 1842 1843 i2c_set_clientdata(client, data); 1844 mutex_init(&data->update_lock); 1845 1846 /* Set the VRM version */ 1847 data->vrm = vid_which_vrm(); 1848 1849 /* Initialize the ADM1026 chip */ 1850 adm1026_init_client(client); 1851 1852 /* Register sysfs hooks */ 1853 err = sysfs_create_group(&client->dev.kobj, &adm1026_group); 1854 if (err) 1855 return err; 1856 if (data->config1 & CFG1_AIN8_9) 1857 err = sysfs_create_group(&client->dev.kobj, 1858 &adm1026_group_in8_9); 1859 else 1860 err = sysfs_create_group(&client->dev.kobj, 1861 &adm1026_group_temp3); 1862 if (err) 1863 goto exitremove; 1864 1865 data->hwmon_dev = hwmon_device_register(&client->dev); 1866 if (IS_ERR(data->hwmon_dev)) { 1867 err = PTR_ERR(data->hwmon_dev); 1868 goto exitremove; 1869 } 1870 1871 return 0; 1872 1873 /* Error out and cleanup code */ 1874 exitremove: 1875 sysfs_remove_group(&client->dev.kobj, &adm1026_group); 1876 if (data->config1 & CFG1_AIN8_9) 1877 sysfs_remove_group(&client->dev.kobj, &adm1026_group_in8_9); 1878 else 1879 sysfs_remove_group(&client->dev.kobj, &adm1026_group_temp3); 1880 return err; 1881 } 1882 1883 static int adm1026_remove(struct i2c_client *client) 1884 { 1885 struct adm1026_data *data = i2c_get_clientdata(client); 1886 hwmon_device_unregister(data->hwmon_dev); 1887 sysfs_remove_group(&client->dev.kobj, &adm1026_group); 1888 if (data->config1 & CFG1_AIN8_9) 1889 sysfs_remove_group(&client->dev.kobj, &adm1026_group_in8_9); 1890 else 1891 sysfs_remove_group(&client->dev.kobj, &adm1026_group_temp3); 1892 return 0; 1893 } 1894 1895 module_i2c_driver(adm1026_driver); 1896 1897 MODULE_LICENSE("GPL"); 1898 MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, " 1899 "Justin Thiessen <jthiessen@penguincomputing.com>"); 1900 MODULE_DESCRIPTION("ADM1026 driver"); 1901