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