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