iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hwmon: (nct6775) Use nct6775_*() function pointers in nct6775_data.

Browse Source 
Prepare for platform specific callbacks usage:
* Use nct6775 function pointers in struct nct6775_data instead direct
  calls.

BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
Co-developed-by: Bernhard Seibold <mail@bernhard-seibold.de>
Signed-off-by: Bernhard Seibold <mail@bernhard-seibold.de>
Cc: Andy Shevchenko <andriy.shevchenko@intel.com>
Cc: Guenter Roeck <linux@roeck-us.net>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
Link: https://lore.kernel.org/r/20210917220240.56553-3-pauk.denis@gmail.com
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
This commit is contained in:
Denis Pauk 2021-09-18 01:02:39 +03:00 committed by Guenter Roeck
parent 2e7b988696
commit 4914036eb6
1 changed files with 143 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

283
drivers/hwmon/nct6775.c
View File

@ -1232,6 +1232,10 @@ struct nct6775_data {
u8 fandiv1; u8 fandiv1;
u8 fandiv2; u8 fandiv2;
u8 sio_reg_enable; u8 sio_reg_enable;
/* nct6775_*() callbacks */
u16 (*read_value)(struct nct6775_data *data, u16 reg);
int (*write_value)(struct nct6775_data *data, u16 reg, u16 value);
}; };
struct sensor_device_template { struct sensor_device_template {
@ -1471,7 +1475,7 @@ static u16 nct6775_read_temp(struct nct6775_data *data, u16 reg)
{ {
u16 res; u16 res;
res = nct6775_read_value(data, reg); res = data->read_value(data, reg);
if (!is_word_sized(data, reg)) if (!is_word_sized(data, reg))
res <<= 8; res <<= 8;
@ -1482,7 +1486,7 @@ static int nct6775_write_temp(struct nct6775_data *data, u16 reg, u16 value)
{ {
if (!is_word_sized(data, reg)) if (!is_word_sized(data, reg))
value >>= 8; value >>= 8;
return nct6775_write_value(data, reg, value); return data->write_value(data, reg, value);
} }
/* This function assumes that the caller holds data->update_lock */ /* This function assumes that the caller holds data->update_lock */
@ -1492,24 +1496,24 @@ static void nct6775_write_fan_div(struct nct6775_data *data, int nr)
switch (nr) { switch (nr) {
case 0: case 0:
reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x70) reg = (data->read_value(data, NCT6775_REG_FANDIV1) & 0x70)
| (data->fan_div[0] & 0x7); | (data->fan_div[0] & 0x7);
nct6775_write_value(data, NCT6775_REG_FANDIV1, reg); data->write_value(data, NCT6775_REG_FANDIV1, reg);
break; break;
case 1: case 1:
reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x7) reg = (data->read_value(data, NCT6775_REG_FANDIV1) & 0x7)
| ((data->fan_div[1] << 4) & 0x70); | ((data->fan_div[1] << 4) & 0x70);
nct6775_write_value(data, NCT6775_REG_FANDIV1, reg); data->write_value(data, NCT6775_REG_FANDIV1, reg);
break; break;
case 2: case 2:
reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x70) reg = (data->read_value(data, NCT6775_REG_FANDIV2) & 0x70)
| (data->fan_div[2] & 0x7); | (data->fan_div[2] & 0x7);
nct6775_write_value(data, NCT6775_REG_FANDIV2, reg); data->write_value(data, NCT6775_REG_FANDIV2, reg);
break; break;
case 3: case 3:
reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x7) reg = (data->read_value(data, NCT6775_REG_FANDIV2) & 0x7)
| ((data->fan_div[3] << 4) & 0x70); | ((data->fan_div[3] << 4) & 0x70);
nct6775_write_value(data, NCT6775_REG_FANDIV2, reg); data->write_value(data, NCT6775_REG_FANDIV2, reg);
break; break;
} }
} }
@ -1524,10 +1528,10 @@ static void nct6775_update_fan_div(struct nct6775_data *data)
{ {
u8 i; u8 i;
i = nct6775_read_value(data, NCT6775_REG_FANDIV1); i = data->read_value(data, NCT6775_REG_FANDIV1);
data->fan_div[0] = i & 0x7; data->fan_div[0] = i & 0x7;
data->fan_div[1] = (i & 0x70) >> 4; data->fan_div[1] = (i & 0x70) >> 4;
i = nct6775_read_value(data, NCT6775_REG_FANDIV2); i = data->read_value(data, NCT6775_REG_FANDIV2);
data->fan_div[2] = i & 0x7; data->fan_div[2] = i & 0x7;
if (data->has_fan & BIT(3)) if (data->has_fan & BIT(3))
data->fan_div[3] = (i & 0x70) >> 4; data->fan_div[3] = (i & 0x70) >> 4;
@ -1575,11 +1579,11 @@ static void nct6775_init_fan_common(struct device *dev,
*/ */
for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) { for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
if (data->has_fan_min & BIT(i)) { if (data->has_fan_min & BIT(i)) {
reg = nct6775_read_value(data, data->REG_FAN_MIN[i]); reg = data->read_value(data, data->REG_FAN_MIN[i]);
if (!reg) if (!reg)
nct6775_write_value(data, data->REG_FAN_MIN[i], data->write_value(data, data->REG_FAN_MIN[i],
data->has_fan_div ? 0xff data->has_fan_div ? 0xff
: 0xff1f); : 0xff1f);
} }
} }
} }
@ -1623,8 +1627,8 @@ static void nct6775_select_fan_div(struct device *dev,
} }
if (fan_min != data->fan_min[nr]) { if (fan_min != data->fan_min[nr]) {
data->fan_min[nr] = fan_min; data->fan_min[nr] = fan_min;
nct6775_write_value(data, data->REG_FAN_MIN[nr], data->write_value(data, data->REG_FAN_MIN[nr],
fan_min); fan_min);
} }
} }
data->fan_div[nr] = fan_div; data->fan_div[nr] = fan_div;
@ -1644,16 +1648,15 @@ static void nct6775_update_pwm(struct device *dev)
continue; continue;
duty_is_dc = data->REG_PWM_MODE[i] && duty_is_dc = data->REG_PWM_MODE[i] &&
(nct6775_read_value(data, data->REG_PWM_MODE[i]) (data->read_value(data, data->REG_PWM_MODE[i])
& data->PWM_MODE_MASK[i]); & data->PWM_MODE_MASK[i]);
data->pwm_mode[i] = !duty_is_dc; data->pwm_mode[i] = !duty_is_dc;
fanmodecfg = nct6775_read_value(data, data->REG_FAN_MODE[i]); fanmodecfg = data->read_value(data, data->REG_FAN_MODE[i]);
for (j = 0; j < ARRAY_SIZE(data->REG_PWM); j++) { for (j = 0; j < ARRAY_SIZE(data->REG_PWM); j++) {
if (data->REG_PWM[j] && data->REG_PWM[j][i]) { if (data->REG_PWM[j] && data->REG_PWM[j][i]) {
data->pwm[j][i] data->pwm[j][i] = data->read_value(data,
= nct6775_read_value(data, data->REG_PWM[j][i]);
data->REG_PWM[j][i]);
} }
} }
@ -1668,17 +1671,17 @@ static void nct6775_update_pwm(struct device *dev)
u8 t = fanmodecfg & 0x0f; u8 t = fanmodecfg & 0x0f;
if (data->REG_TOLERANCE_H) { if (data->REG_TOLERANCE_H) {
t |= (nct6775_read_value(data, t |= (data->read_value(data,
data->REG_TOLERANCE_H[i]) & 0x70) >> 1; data->REG_TOLERANCE_H[i]) & 0x70) >> 1;
} }
data->target_speed_tolerance[i] = t; data->target_speed_tolerance[i] = t;
} }
data->temp_tolerance[1][i] = data->temp_tolerance[1][i] =
nct6775_read_value(data, data->read_value(data,
data->REG_CRITICAL_TEMP_TOLERANCE[i]); data->REG_CRITICAL_TEMP_TOLERANCE[i]);
reg = nct6775_read_value(data, data->REG_TEMP_SEL[i]); reg = data->read_value(data, data->REG_TEMP_SEL[i]);
data->pwm_temp_sel[i] = reg & 0x1f; data->pwm_temp_sel[i] = reg & 0x1f;
/* If fan can stop, report floor as 0 */ /* If fan can stop, report floor as 0 */
if (reg & 0x80) if (reg & 0x80)
@ -1687,7 +1690,7 @@ static void nct6775_update_pwm(struct device *dev)
if (!data->REG_WEIGHT_TEMP_SEL[i]) if (!data->REG_WEIGHT_TEMP_SEL[i])
continue; continue;
reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[i]); reg = data->read_value(data, data->REG_WEIGHT_TEMP_SEL[i]);
data->pwm_weight_temp_sel[i] = reg & 0x1f; data->pwm_weight_temp_sel[i] = reg & 0x1f;
/* If weight is disabled, report weight source as 0 */ /* If weight is disabled, report weight source as 0 */
if (!(reg & 0x80)) if (!(reg & 0x80))
@ -1695,9 +1698,8 @@ static void nct6775_update_pwm(struct device *dev)
/* Weight temp data */ /* Weight temp data */
for (j = 0; j < ARRAY_SIZE(data->weight_temp); j++) { for (j = 0; j < ARRAY_SIZE(data->weight_temp); j++) {
data->weight_temp[j][i] data->weight_temp[j][i] = data->read_value(data,
= nct6775_read_value(data, data->REG_WEIGHT_TEMP[j][i]);
data->REG_WEIGHT_TEMP[j][i]);
} }
} }
} }
@ -1715,10 +1717,10 @@ static void nct6775_update_pwm_limits(struct device *dev)
for (j = 0; j < ARRAY_SIZE(data->fan_time); j++) { for (j = 0; j < ARRAY_SIZE(data->fan_time); j++) {
data->fan_time[j][i] = data->fan_time[j][i] =
nct6775_read_value(data, data->REG_FAN_TIME[j][i]); data->read_value(data, data->REG_FAN_TIME[j][i]);
} }
reg_t = nct6775_read_value(data, data->REG_TARGET[i]); reg_t = data->read_value(data, data->REG_TARGET[i]);
/* Update only in matching mode or if never updated */ /* Update only in matching mode or if never updated */
if (!data->target_temp[i] || if (!data->target_temp[i] ||
data->pwm_enable[i] == thermal_cruise) data->pwm_enable[i] == thermal_cruise)
@ -1726,7 +1728,7 @@ static void nct6775_update_pwm_limits(struct device *dev)
if (!data->target_speed[i] || if (!data->target_speed[i] ||
data->pwm_enable[i] == speed_cruise) { data->pwm_enable[i] == speed_cruise) {
if (data->REG_TOLERANCE_H) { if (data->REG_TOLERANCE_H) {
reg_t |= (nct6775_read_value(data, reg_t |= (data->read_value(data,
data->REG_TOLERANCE_H[i]) & 0x0f) << 8; data->REG_TOLERANCE_H[i]) & 0x0f) << 8;
} }
data->target_speed[i] = reg_t; data->target_speed[i] = reg_t;
@ -1734,21 +1736,21 @@ static void nct6775_update_pwm_limits(struct device *dev)
for (j = 0; j < data->auto_pwm_num; j++) { for (j = 0; j < data->auto_pwm_num; j++) {
data->auto_pwm[i][j] = data->auto_pwm[i][j] =
nct6775_read_value(data, data->read_value(data,
NCT6775_AUTO_PWM(data, i, j)); NCT6775_AUTO_PWM(data, i, j));
data->auto_temp[i][j] = data->auto_temp[i][j] =
nct6775_read_value(data, data->read_value(data,
NCT6775_AUTO_TEMP(data, i, j)); NCT6775_AUTO_TEMP(data, i, j));
} }
/* critical auto_pwm temperature data */ /* critical auto_pwm temperature data */
data->auto_temp[i][data->auto_pwm_num] = data->auto_temp[i][data->auto_pwm_num] =
nct6775_read_value(data, data->REG_CRITICAL_TEMP[i]); data->read_value(data, data->REG_CRITICAL_TEMP[i]);
switch (data->kind) { switch (data->kind) {
case nct6775: case nct6775:
reg = nct6775_read_value(data, reg = data->read_value(data,
NCT6775_REG_CRITICAL_ENAB[i]); NCT6775_REG_CRITICAL_ENAB[i]);
data->auto_pwm[i][data->auto_pwm_num] = data->auto_pwm[i][data->auto_pwm_num] =
(reg & 0x02) ? 0xff : 0x00; (reg & 0x02) ? 0xff : 0x00;
break; break;
@ -1765,10 +1767,10 @@ static void nct6775_update_pwm_limits(struct device *dev)
case nct6796: case nct6796:
case nct6797: case nct6797:
case nct6798: case nct6798:
reg = nct6775_read_value(data, reg = data->read_value(data,
data->REG_CRITICAL_PWM_ENABLE[i]); data->REG_CRITICAL_PWM_ENABLE[i]);
if (reg & data->CRITICAL_PWM_ENABLE_MASK) if (reg & data->CRITICAL_PWM_ENABLE_MASK)
reg = nct6775_read_value(data, reg = data->read_value(data,
data->REG_CRITICAL_PWM[i]); data->REG_CRITICAL_PWM[i]);
else else
reg = 0xff; reg = 0xff;
@ -1795,11 +1797,11 @@ static struct nct6775_data *nct6775_update_device(struct device *dev)
if (!(data->have_in & BIT(i))) if (!(data->have_in & BIT(i)))
continue; continue;
data->in[i][0] = nct6775_read_value(data, data->in[i][0] = data->read_value(data,
data->REG_VIN[i]); data->REG_VIN[i]);
data->in[i][1] = nct6775_read_value(data, data->in[i][1] = data->read_value(data,
data->REG_IN_MINMAX[0][i]); data->REG_IN_MINMAX[0][i]);
data->in[i][2] = nct6775_read_value(data, data->in[i][2] = data->read_value(data,
data->REG_IN_MINMAX[1][i]); data->REG_IN_MINMAX[1][i]);
} }
@ -1810,18 +1812,18 @@ static struct nct6775_data *nct6775_update_device(struct device *dev)
if (!(data->has_fan & BIT(i))) if (!(data->has_fan & BIT(i)))
continue; continue;
reg = nct6775_read_value(data, data->REG_FAN[i]); reg = data->read_value(data, data->REG_FAN[i]);
data->rpm[i] = data->fan_from_reg(reg, data->rpm[i] = data->fan_from_reg(reg,
data->fan_div[i]); data->fan_div[i]);
if (data->has_fan_min & BIT(i)) if (data->has_fan_min & BIT(i))
data->fan_min[i] = nct6775_read_value(data, data->fan_min[i] = data->read_value(data,
data->REG_FAN_MIN[i]); data->REG_FAN_MIN[i]);
if (data->REG_FAN_PULSES[i]) { if (data->REG_FAN_PULSES[i]) {
data->fan_pulses[i] = data->fan_pulses[i] =
(nct6775_read_value(data, (data->read_value(data,
data->REG_FAN_PULSES[i]) data->REG_FAN_PULSES[i])
>> data->FAN_PULSE_SHIFT[i]) & 0x03; >> data->FAN_PULSE_SHIFT[i]) & 0x03;
} }
@ -1837,15 +1839,14 @@ static struct nct6775_data *nct6775_update_device(struct device *dev)
continue; continue;
for (j = 0; j < ARRAY_SIZE(data->reg_temp); j++) { for (j = 0; j < ARRAY_SIZE(data->reg_temp); j++) {
if (data->reg_temp[j][i]) if (data->reg_temp[j][i])
data->temp[j][i] data->temp[j][i] = nct6775_read_temp(data,
= nct6775_read_temp(data, data->reg_temp[j][i]);
data->reg_temp[j][i]);
} }
if (i >= NUM_TEMP_FIXED || if (i >= NUM_TEMP_FIXED ||
!(data->have_temp_fixed & BIT(i))) !(data->have_temp_fixed & BIT(i)))
continue; continue;
data->temp_offset[i] data->temp_offset[i] = data->read_value(data,
= nct6775_read_value(data, data->REG_TEMP_OFFSET[i]); data->REG_TEMP_OFFSET[i]);
} }
data->alarms = 0; data->alarms = 0;
@ -1854,7 +1855,7 @@ static struct nct6775_data *nct6775_update_device(struct device *dev)
if (!data->REG_ALARM[i]) if (!data->REG_ALARM[i])
continue; continue;
alarm = nct6775_read_value(data, data->REG_ALARM[i]); alarm = data->read_value(data, data->REG_ALARM[i]);
data->alarms |= ((u64)alarm) << (i << 3); data->alarms |= ((u64)alarm) << (i << 3);
} }
@ -1864,7 +1865,7 @@ static struct nct6775_data *nct6775_update_device(struct device *dev)
if (!data->REG_BEEP[i]) if (!data->REG_BEEP[i])
continue; continue;
beep = nct6775_read_value(data, data->REG_BEEP[i]); beep = data->read_value(data, data->REG_BEEP[i]);
data->beeps |= ((u64)beep) << (i << 3); data->beeps |= ((u64)beep) << (i << 3);
} }
@ -1906,8 +1907,8 @@ store_in_reg(struct device *dev, struct device_attribute *attr, const char *buf,
return err; return err;
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->in[nr][index] = in_to_reg(val, nr); data->in[nr][index] = in_to_reg(val, nr);
nct6775_write_value(data, data->REG_IN_MINMAX[index - 1][nr], data->write_value(data, data->REG_IN_MINMAX[index - 1][nr],
data->in[nr][index]); data->in[nr][index]);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
} }
@ -1931,8 +1932,8 @@ static int find_temp_source(struct nct6775_data *data, int index, int count)
for (nr = 0; nr < count; nr++) { for (nr = 0; nr < count; nr++) {
int src; int src;
src = nct6775_read_value(data, src = data->read_value(data,
data->REG_TEMP_SOURCE[nr]) & 0x1f; data->REG_TEMP_SOURCE[nr]) & 0x1f;
if (src == source) if (src == source)
return nr; return nr;
} }
@ -1993,8 +1994,8 @@ store_beep(struct device *dev, struct device_attribute *attr, const char *buf,
data->beeps |= (1ULL << nr); data->beeps |= (1ULL << nr);
else else
data->beeps &= ~(1ULL << nr); data->beeps &= ~(1ULL << nr);
nct6775_write_value(data, data->REG_BEEP[regindex], data->write_value(data, data->REG_BEEP[regindex],
(data->beeps >> (regindex << 3)) & 0xff); (data->beeps >> (regindex << 3)) & 0xff);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
} }
@ -2049,8 +2050,8 @@ store_temp_beep(struct device *dev, struct device_attribute *attr,
data->beeps |= (1ULL << bit); data->beeps |= (1ULL << bit);
else else
data->beeps &= ~(1ULL << bit); data->beeps &= ~(1ULL << bit);
nct6775_write_value(data, data->REG_BEEP[regindex], data->write_value(data, data->REG_BEEP[regindex],
(data->beeps >> (regindex << 3)) & 0xff); (data->beeps >> (regindex << 3)) & 0xff);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
@ -2217,7 +2218,7 @@ write_div:
} }
write_min: write_min:
nct6775_write_value(data, data->REG_FAN_MIN[nr], data->fan_min[nr]); data->write_value(data, data->REG_FAN_MIN[nr], data->fan_min[nr]);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
@ -2253,10 +2254,10 @@ store_fan_pulses(struct device *dev, struct device_attribute *attr,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->fan_pulses[nr] = val & 3; data->fan_pulses[nr] = val & 3;
reg = nct6775_read_value(data, data->REG_FAN_PULSES[nr]); reg = data->read_value(data, data->REG_FAN_PULSES[nr]);
reg &= ~(0x03 << data->FAN_PULSE_SHIFT[nr]); reg &= ~(0x03 << data->FAN_PULSE_SHIFT[nr]);
reg |= (val & 3) << data->FAN_PULSE_SHIFT[nr]; reg |= (val & 3) << data->FAN_PULSE_SHIFT[nr];
nct6775_write_value(data, data->REG_FAN_PULSES[nr], reg); data->write_value(data, data->REG_FAN_PULSES[nr], reg);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
@ -2390,7 +2391,7 @@ store_temp_offset(struct device *dev, struct device_attribute *attr,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->temp_offset[nr] = val; data->temp_offset[nr] = val;
nct6775_write_value(data, data->REG_TEMP_OFFSET[nr], val); data->write_value(data, data->REG_TEMP_OFFSET[nr], val);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
@ -2429,8 +2430,8 @@ store_temp_type(struct device *dev, struct device_attribute *attr,
data->temp_type[nr] = val; data->temp_type[nr] = val;
vbit = 0x02 << nr; vbit = 0x02 << nr;
dbit = data->DIODE_MASK << nr; dbit = data->DIODE_MASK << nr;
vbat = nct6775_read_value(data, data->REG_VBAT) & ~vbit; vbat = data->read_value(data, data->REG_VBAT) & ~vbit;
diode = nct6775_read_value(data, data->REG_DIODE) & ~dbit; diode = data->read_value(data, data->REG_DIODE) & ~dbit;
switch (val) { switch (val) {
case 1: /* CPU diode (diode, current mode) */ case 1: /* CPU diode (diode, current mode) */
vbat |= vbit; vbat |= vbit;
@ -2442,8 +2443,8 @@ store_temp_type(struct device *dev, struct device_attribute *attr,
case 4: /* thermistor */ case 4: /* thermistor */
break; break;
} }
nct6775_write_value(data, data->REG_VBAT, vbat); data->write_value(data, data->REG_VBAT, vbat);
nct6775_write_value(data, data->REG_DIODE, diode); data->write_value(data, data->REG_DIODE, diode);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
@ -2567,11 +2568,11 @@ store_pwm_mode(struct device *dev, struct device_attribute *attr,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->pwm_mode[nr] = val; data->pwm_mode[nr] = val;
reg = nct6775_read_value(data, data->REG_PWM_MODE[nr]); reg = data->read_value(data, data->REG_PWM_MODE[nr]);
reg &= ~data->PWM_MODE_MASK[nr]; reg &= ~data->PWM_MODE_MASK[nr];
if (!val) if (!val)
reg |= data->PWM_MODE_MASK[nr]; reg |= data->PWM_MODE_MASK[nr];
nct6775_write_value(data, data->REG_PWM_MODE[nr], reg); data->write_value(data, data->REG_PWM_MODE[nr], reg);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
} }
@ -2590,7 +2591,7 @@ show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
* Otherwise, show the configured value. * Otherwise, show the configured value.
*/ */
if (index == 0 && data->pwm_enable[nr] > manual) if (index == 0 && data->pwm_enable[nr] > manual)
pwm = nct6775_read_value(data, data->REG_PWM_READ[nr]); pwm = data->read_value(data, data->REG_PWM_READ[nr]);
else else
pwm = data->pwm[index][nr]; pwm = data->pwm[index][nr];
@ -2619,13 +2620,13 @@ store_pwm(struct device *dev, struct device_attribute *attr, const char *buf,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->pwm[index][nr] = val; data->pwm[index][nr] = val;
nct6775_write_value(data, data->REG_PWM[index][nr], val); data->write_value(data, data->REG_PWM[index][nr], val);
if (index == 2) { /* floor: disable if val == 0 */ if (index == 2) { /* floor: disable if val == 0 */
reg = nct6775_read_value(data, data->REG_TEMP_SEL[nr]); reg = data->read_value(data, data->REG_TEMP_SEL[nr]);
reg &= 0x7f; reg &= 0x7f;
if (val) if (val)
reg |= 0x80; reg |= 0x80;
nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg); data->write_value(data, data->REG_TEMP_SEL[nr], reg);
} }
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
@ -2664,29 +2665,29 @@ static void pwm_update_registers(struct nct6775_data *data, int nr)
case manual: case manual:
break; break;
case speed_cruise: case speed_cruise:
reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]); reg = data->read_value(data, data->REG_FAN_MODE[nr]);
reg = (reg & ~data->tolerance_mask) | reg = (reg & ~data->tolerance_mask) |
(data->target_speed_tolerance[nr] & data->tolerance_mask); (data->target_speed_tolerance[nr] & data->tolerance_mask);
nct6775_write_value(data, data->REG_FAN_MODE[nr], reg); data->write_value(data, data->REG_FAN_MODE[nr], reg);
nct6775_write_value(data, data->REG_TARGET[nr], data->write_value(data, data->REG_TARGET[nr],
data->target_speed[nr] & 0xff); data->target_speed[nr] & 0xff);
if (data->REG_TOLERANCE_H) { if (data->REG_TOLERANCE_H) {
reg = (data->target_speed[nr] >> 8) & 0x0f; reg = (data->target_speed[nr] >> 8) & 0x0f;
reg |= (data->target_speed_tolerance[nr] & 0x38) << 1; reg |= (data->target_speed_tolerance[nr] & 0x38) << 1;
nct6775_write_value(data, data->write_value(data,
data->REG_TOLERANCE_H[nr], data->REG_TOLERANCE_H[nr],
reg); reg);
} }
break; break;
case thermal_cruise: case thermal_cruise:
nct6775_write_value(data, data->REG_TARGET[nr], data->write_value(data, data->REG_TARGET[nr],
data->target_temp[nr]); data->target_temp[nr]);
fallthrough; fallthrough;
default: default:
reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]); reg = data->read_value(data, data->REG_FAN_MODE[nr]);
reg = (reg & ~data->tolerance_mask) | reg = (reg & ~data->tolerance_mask) |
data->temp_tolerance[0][nr]; data->temp_tolerance[0][nr];
nct6775_write_value(data, data->REG_FAN_MODE[nr], reg); data->write_value(data, data->REG_FAN_MODE[nr], reg);
break; break;
} }
} }
@ -2734,13 +2735,13 @@ store_pwm_enable(struct device *dev, struct device_attribute *attr,
* turn off pwm control: select manual mode, set pwm to maximum * turn off pwm control: select manual mode, set pwm to maximum
*/ */
data->pwm[0][nr] = 255; data->pwm[0][nr] = 255;
nct6775_write_value(data, data->REG_PWM[0][nr], 255); data->write_value(data, data->REG_PWM[0][nr], 255);
} }
pwm_update_registers(data, nr); pwm_update_registers(data, nr);
reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]); reg = data->read_value(data, data->REG_FAN_MODE[nr]);
reg &= 0x0f; reg &= 0x0f;
reg |= pwm_enable_to_reg(val) << 4; reg |= pwm_enable_to_reg(val) << 4;
nct6775_write_value(data, data->REG_FAN_MODE[nr], reg); data->write_value(data, data->REG_FAN_MODE[nr], reg);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
} }
@ -2793,10 +2794,10 @@ store_pwm_temp_sel(struct device *dev, struct device_attribute *attr,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
src = data->temp_src[val - 1]; src = data->temp_src[val - 1];
data->pwm_temp_sel[nr] = src; data->pwm_temp_sel[nr] = src;
reg = nct6775_read_value(data, data->REG_TEMP_SEL[nr]); reg = data->read_value(data, data->REG_TEMP_SEL[nr]);
reg &= 0xe0; reg &= 0xe0;
reg |= src; reg |= src;
nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg); data->write_value(data, data->REG_TEMP_SEL[nr], reg);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
@ -2838,15 +2839,15 @@ store_pwm_weight_temp_sel(struct device *dev, struct device_attribute *attr,
if (val) { if (val) {
src = data->temp_src[val - 1]; src = data->temp_src[val - 1];
data->pwm_weight_temp_sel[nr] = src; data->pwm_weight_temp_sel[nr] = src;
reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]); reg = data->read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]);
reg &= 0xe0; reg &= 0xe0;
reg |= (src | 0x80); reg |= (src | 0x80);
nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg); data->write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
} else { } else {
data->pwm_weight_temp_sel[nr] = 0; data->pwm_weight_temp_sel[nr] = 0;
reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]); reg = data->read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]);
reg &= 0x7f; reg &= 0x7f;
nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg); data->write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
} }
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
@ -2958,9 +2959,9 @@ store_temp_tolerance(struct device *dev, struct device_attribute *attr,
if (index) if (index)
pwm_update_registers(data, nr); pwm_update_registers(data, nr);
else else
nct6775_write_value(data, data->write_value(data,
data->REG_CRITICAL_TEMP_TOLERANCE[nr], data->REG_CRITICAL_TEMP_TOLERANCE[nr],
val); val);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
} }
@ -3083,7 +3084,7 @@ store_weight_temp(struct device *dev, struct device_attribute *attr,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->weight_temp[index][nr] = val; data->weight_temp[index][nr] = val;
nct6775_write_value(data, data->REG_WEIGHT_TEMP[index][nr], val); data->write_value(data, data->REG_WEIGHT_TEMP[index][nr], val);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
} }
@ -3132,7 +3133,7 @@ store_fan_time(struct device *dev, struct device_attribute *attr,
val = step_time_to_reg(val, data->pwm_mode[nr]); val = step_time_to_reg(val, data->pwm_mode[nr]);
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->fan_time[index][nr] = val; data->fan_time[index][nr] = val;
nct6775_write_value(data, data->REG_FAN_TIME[index][nr], val); data->write_value(data, data->REG_FAN_TIME[index][nr], val);
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
return count; return count;
} }
@ -3174,21 +3175,21 @@ store_auto_pwm(struct device *dev, struct device_attribute *attr,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->auto_pwm[nr][point] = val; data->auto_pwm[nr][point] = val;
if (point < data->auto_pwm_num) { if (point < data->auto_pwm_num) {
nct6775_write_value(data, data->write_value(data,
NCT6775_AUTO_PWM(data, nr, point), NCT6775_AUTO_PWM(data, nr, point),
data->auto_pwm[nr][point]); data->auto_pwm[nr][point]);
} else { } else {
switch (data->kind) { switch (data->kind) {
case nct6775: case nct6775:
/* disable if needed (pwm == 0) */ /* disable if needed (pwm == 0) */
reg = nct6775_read_value(data, reg = data->read_value(data,
NCT6775_REG_CRITICAL_ENAB[nr]); NCT6775_REG_CRITICAL_ENAB[nr]);
if (val) if (val)
reg |= 0x02; reg |= 0x02;
else else
reg &= ~0x02; reg &= ~0x02;
nct6775_write_value(data, NCT6775_REG_CRITICAL_ENAB[nr], data->write_value(data, NCT6775_REG_CRITICAL_ENAB[nr],
reg); reg);
break; break;
case nct6776: case nct6776:
break; /* always enabled, nothing to do */ break; /* always enabled, nothing to do */
@ -3202,17 +3203,17 @@ store_auto_pwm(struct device *dev, struct device_attribute *attr,
case nct6796: case nct6796:
case nct6797: case nct6797:
case nct6798: case nct6798:
nct6775_write_value(data, data->REG_CRITICAL_PWM[nr], data->write_value(data, data->REG_CRITICAL_PWM[nr],
val); val);
reg = nct6775_read_value(data, reg = data->read_value(data,
data->REG_CRITICAL_PWM_ENABLE[nr]); data->REG_CRITICAL_PWM_ENABLE[nr]);
if (val == 255) if (val == 255)
reg &= ~data->CRITICAL_PWM_ENABLE_MASK; reg &= ~data->CRITICAL_PWM_ENABLE_MASK;
else else
reg |= data->CRITICAL_PWM_ENABLE_MASK; reg |= data->CRITICAL_PWM_ENABLE_MASK;
nct6775_write_value(data, data->write_value(data,
data->REG_CRITICAL_PWM_ENABLE[nr], data->REG_CRITICAL_PWM_ENABLE[nr],
reg); reg);
break; break;
} }
} }
@ -3255,11 +3256,11 @@ store_auto_temp(struct device *dev, struct device_attribute *attr,
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->auto_temp[nr][point] = DIV_ROUND_CLOSEST(val, 1000); data->auto_temp[nr][point] = DIV_ROUND_CLOSEST(val, 1000);
if (point < data->auto_pwm_num) { if (point < data->auto_pwm_num) {
nct6775_write_value(data, data->write_value(data,
NCT6775_AUTO_TEMP(data, nr, point), NCT6775_AUTO_TEMP(data, nr, point),
data->auto_temp[nr][point]); data->auto_temp[nr][point]);
} else { } else {
nct6775_write_value(data, data->REG_CRITICAL_TEMP[nr], data->write_value(data, data->REG_CRITICAL_TEMP[nr],
data->auto_temp[nr][point]); data->auto_temp[nr][point]);
} }
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
@ -3519,9 +3520,9 @@ static inline void nct6775_init_device(struct nct6775_data *data)
/* Start monitoring if needed */ /* Start monitoring if needed */
if (data->REG_CONFIG) { if (data->REG_CONFIG) {
tmp = nct6775_read_value(data, data->REG_CONFIG); tmp = data->read_value(data, data->REG_CONFIG);
if (!(tmp & 0x01)) if (!(tmp & 0x01))
nct6775_write_value(data, data->REG_CONFIG, tmp | 0x01); data->write_value(data, data->REG_CONFIG, tmp | 0x01);
} }
/* Enable temperature sensors if needed */ /* Enable temperature sensors if needed */
@ -3530,18 +3531,18 @@ static inline void nct6775_init_device(struct nct6775_data *data)
continue; continue;
if (!data->reg_temp_config[i]) if (!data->reg_temp_config[i])
continue; continue;
tmp = nct6775_read_value(data, data->reg_temp_config[i]); tmp = data->read_value(data, data->reg_temp_config[i]);
if (tmp & 0x01) if (tmp & 0x01)
nct6775_write_value(data, data->reg_temp_config[i], data->write_value(data, data->reg_temp_config[i],
tmp & 0xfe); tmp & 0xfe);
} }
/* Enable VBAT monitoring if needed */ /* Enable VBAT monitoring if needed */
tmp = nct6775_read_value(data, data->REG_VBAT); tmp = data->read_value(data, data->REG_VBAT);
if (!(tmp & 0x01)) if (!(tmp & 0x01))
nct6775_write_value(data, data->REG_VBAT, tmp | 0x01); data->write_value(data, data->REG_VBAT, tmp | 0x01);
diode = nct6775_read_value(data, data->REG_DIODE); diode = data->read_value(data, data->REG_DIODE);
for (i = 0; i < data->temp_fixed_num; i++) { for (i = 0; i < data->temp_fixed_num; i++) {
if (!(data->have_temp_fixed & BIT(i))) if (!(data->have_temp_fixed & BIT(i)))
@ -3786,7 +3787,7 @@ static void add_temp_sensors(struct nct6775_data *data, const u16 *regp,
if (!regp[i]) if (!regp[i])
continue; continue;
src = nct6775_read_value(data, regp[i]); src = data->read_value(data, regp[i]);
src &= 0x1f; src &= 0x1f;
if (!src || (*mask & BIT(src))) if (!src || (*mask & BIT(src)))
continue; continue;
@ -3794,7 +3795,7 @@ static void add_temp_sensors(struct nct6775_data *data, const u16 *regp,
continue; continue;
index = __ffs(*available); index = __ffs(*available);
nct6775_write_value(data, data->REG_TEMP_SOURCE[index], src); data->write_value(data, data->REG_TEMP_SOURCE[index], src);
*available &= ~BIT(index); *available &= ~BIT(index);
*mask |= BIT(src); *mask |= BIT(src);
} }
@ -3830,6 +3831,8 @@ static int nct6775_probe(struct platform_device *pdev)
data->kind = sio_data->kind; data->kind = sio_data->kind;
data->sioreg = sio_data->sioreg; data->sioreg = sio_data->sioreg;
data->addr = res->start; data->addr = res->start;
data->read_value = nct6775_read_value;
data->write_value = nct6775_write_value;
mutex_init(&data->update_lock); mutex_init(&data->update_lock);
data->name = nct6775_device_names[data->kind]; data->name = nct6775_device_names[data->kind];
data->bank = 0xff; /* Force initial bank selection */ data->bank = 0xff; /* Force initial bank selection */
@ -4349,7 +4352,7 @@ static int nct6775_probe(struct platform_device *pdev)
if (reg_temp[i] == 0) if (reg_temp[i] == 0)
continue; continue;
src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f; src = data->read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f;
if (!src || (mask & BIT(src))) if (!src || (mask & BIT(src)))
available |= BIT(i); available |= BIT(i);
@ -4369,7 +4372,7 @@ static int nct6775_probe(struct platform_device *pdev)
if (reg_temp[i] == 0) if (reg_temp[i] == 0)
continue; continue;
src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f; src = data->read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f;
if (!src || (mask & BIT(src))) if (!src || (mask & BIT(src)))
continue; continue;
@ -4429,7 +4432,7 @@ static int nct6775_probe(struct platform_device *pdev)
if (reg_temp_mon[i] == 0) if (reg_temp_mon[i] == 0)
continue; continue;
src = nct6775_read_value(data, data->REG_TEMP_SEL[i]) & 0x1f; src = data->read_value(data, data->REG_TEMP_SEL[i]) & 0x1f;
if (!src) if (!src)
continue; continue;
@ -4642,10 +4645,10 @@ static int __maybe_unused nct6775_suspend(struct device *dev)
struct nct6775_data *data = nct6775_update_device(dev); struct nct6775_data *data = nct6775_update_device(dev);
mutex_lock(&data->update_lock); mutex_lock(&data->update_lock);
data->vbat = nct6775_read_value(data, data->REG_VBAT); data->vbat = data->read_value(data, data->REG_VBAT);
if (data->kind == nct6775) { if (data->kind == nct6775) {
data->fandiv1 = nct6775_read_value(data, NCT6775_REG_FANDIV1); data->fandiv1 = data->read_value(data, NCT6775_REG_FANDIV1);
data->fandiv2 = nct6775_read_value(data, NCT6775_REG_FANDIV2); data->fandiv2 = data->read_value(data, NCT6775_REG_FANDIV2);
} }
mutex_unlock(&data->update_lock); mutex_unlock(&data->update_lock);
@ -4684,18 +4687,18 @@ static int __maybe_unused nct6775_resume(struct device *dev)
if (!(data->have_in & BIT(i))) if (!(data->have_in & BIT(i)))
continue; continue;
nct6775_write_value(data, data->REG_IN_MINMAX[0][i], data->write_value(data, data->REG_IN_MINMAX[0][i],
data->in[i][1]); data->in[i][1]);
nct6775_write_value(data, data->REG_IN_MINMAX[1][i], data->write_value(data, data->REG_IN_MINMAX[1][i],
data->in[i][2]); data->in[i][2]);
} }
for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) { for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
if (!(data->has_fan_min & BIT(i))) if (!(data->has_fan_min & BIT(i)))
continue; continue;
nct6775_write_value(data, data->REG_FAN_MIN[i], data->write_value(data, data->REG_FAN_MIN[i],
data->fan_min[i]); data->fan_min[i]);
} }
for (i = 0; i < NUM_TEMP; i++) { for (i = 0; i < NUM_TEMP; i++) {
@ -4709,10 +4712,10 @@ static int __maybe_unused nct6775_resume(struct device *dev)
} }
/* Restore other settings */ /* Restore other settings */
nct6775_write_value(data, data->REG_VBAT, data->vbat); data->write_value(data, data->REG_VBAT, data->vbat);
if (data->kind == nct6775) { if (data->kind == nct6775) {
nct6775_write_value(data, NCT6775_REG_FANDIV1, data->fandiv1); data->write_value(data, NCT6775_REG_FANDIV1, data->fandiv1);
nct6775_write_value(data, NCT6775_REG_FANDIV2, data->fandiv2); data->write_value(data, NCT6775_REG_FANDIV2, data->fandiv2);
} }
abort: abort: