Lines Matching refs:data
64 /* used to set data->name = nct6775_device_names[data->sio_kind] */
81 /* Common and NCT6775 specific data */
192 #define NCT6775_AUTO_TEMP(data, nr, p) ((data)->REG_AUTO_TEMP[nr] + (p))
193 #define NCT6775_AUTO_PWM(data, nr, p) ((data)->REG_AUTO_PWM[nr] + (p))
248 /* NCT6776 specific data */
333 /* NCT6779 specific data */
439 /* NCT6791 specific data */
459 /* NCT6792/NCT6793 specific data */
738 /* NCT6102D/NCT6106D specific data */
839 /* NCT6112D/NCT6114D/NCT6116D specific data */
1077 static int nct6775_add_template_attr_group(struct device *dev, struct nct6775_data *data,
1148 return nct6775_add_attr_group(data, group);
1151 bool nct6775_reg_is_word_sized(struct nct6775_data *data, u16 reg)
1153 switch (data->kind) {
1212 static int nct6775_read_temp(struct nct6775_data *data, u16 reg, u16 *val)
1216 err = nct6775_read_value(data, reg, val);
1220 if (!nct6775_reg_is_word_sized(data, reg))
1226 /* This function assumes that the caller holds data->update_lock */
1227 static int nct6775_write_fan_div(struct nct6775_data *data, int nr)
1234 err = nct6775_read_value(data, fandiv_reg, ®);
1238 reg |= (data->fan_div[nr] & 0x7) << oddshift;
1239 return nct6775_write_value(data, fandiv_reg, reg);
1242 static int nct6775_write_fan_div_common(struct nct6775_data *data, int nr)
1244 if (data->kind == nct6775)
1245 return nct6775_write_fan_div(data, nr);
1249 static int nct6775_update_fan_div(struct nct6775_data *data)
1254 err = nct6775_read_value(data, NCT6775_REG_FANDIV1, &i);
1257 data->fan_div[0] = i & 0x7;
1258 data->fan_div[1] = (i & 0x70) >> 4;
1259 err = nct6775_read_value(data, NCT6775_REG_FANDIV2, &i);
1262 data->fan_div[2] = i & 0x7;
1263 if (data->has_fan & BIT(3))
1264 data->fan_div[3] = (i & 0x70) >> 4;
1269 static int nct6775_update_fan_div_common(struct nct6775_data *data)
1271 if (data->kind == nct6775)
1272 return nct6775_update_fan_div(data);
1276 static int nct6775_init_fan_div(struct nct6775_data *data)
1280 err = nct6775_update_fan_div_common(data);
1290 for (i = 0; i < ARRAY_SIZE(data->fan_div); i++) {
1291 if (!(data->has_fan & BIT(i)))
1293 if (data->fan_div[i] == 0) {
1294 data->fan_div[i] = 7;
1295 err = nct6775_write_fan_div_common(data, i);
1305 struct nct6775_data *data)
1310 if (data->has_fan_div) {
1311 err = nct6775_init_fan_div(data);
1320 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1321 if (data->has_fan_min & BIT(i)) {
1322 err = nct6775_read_value(data, data->REG_FAN_MIN[i], ®);
1326 err = nct6775_write_value(data, data->REG_FAN_MIN[i],
1327 data->has_fan_div ? 0xff : 0xff1f);
1338 struct nct6775_data *data, int nr, u16 reg)
1341 u8 fan_div = data->fan_div[nr];
1344 if (!data->has_fan_div)
1357 if (fan_div != data->fan_div[nr]) {
1359 nr + 1, div_from_reg(data->fan_div[nr]),
1363 if (data->has_fan_min & BIT(nr)) {
1364 fan_min = data->fan_min[nr];
1365 if (fan_div > data->fan_div[nr]) {
1375 if (fan_min != data->fan_min[nr]) {
1376 data->fan_min[nr] = fan_min;
1377 err = nct6775_write_value(data, data->REG_FAN_MIN[nr], fan_min);
1382 data->fan_div[nr] = fan_div;
1383 err = nct6775_write_fan_div_common(data, nr);
1393 struct nct6775_data *data = dev_get_drvdata(dev);
1398 for (i = 0; i < data->pwm_num; i++) {
1399 if (!(data->has_pwm & BIT(i)))
1402 err = nct6775_read_value(data, data->REG_PWM_MODE[i], ®);
1405 duty_is_dc = data->REG_PWM_MODE[i] && (reg & data->PWM_MODE_MASK[i]);
1406 data->pwm_mode[i] = !duty_is_dc;
1408 err = nct6775_read_value(data, data->REG_FAN_MODE[i], &fanmodecfg);
1411 for (j = 0; j < ARRAY_SIZE(data->REG_PWM); j++) {
1412 if (data->REG_PWM[j] && data->REG_PWM[j][i]) {
1413 err = nct6775_read_value(data, data->REG_PWM[j][i], ®);
1416 data->pwm[j][i] = reg;
1420 data->pwm_enable[i] = reg_to_pwm_enable(data->pwm[0][i],
1423 if (!data->temp_tolerance[0][i] ||
1424 data->pwm_enable[i] != speed_cruise)
1425 data->temp_tolerance[0][i] = fanmodecfg & 0x0f;
1426 if (!data->target_speed_tolerance[i] ||
1427 data->pwm_enable[i] == speed_cruise) {
1430 if (data->REG_TOLERANCE_H) {
1431 err = nct6775_read_value(data, data->REG_TOLERANCE_H[i], ®);
1436 data->target_speed_tolerance[i] = t;
1439 err = nct6775_read_value(data, data->REG_CRITICAL_TEMP_TOLERANCE[i], ®);
1442 data->temp_tolerance[1][i] = reg;
1444 err = nct6775_read_value(data, data->REG_TEMP_SEL[i], ®);
1447 data->pwm_temp_sel[i] = reg & 0x1f;
1450 data->pwm[2][i] = 0;
1452 if (!data->REG_WEIGHT_TEMP_SEL[i])
1455 err = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[i], ®);
1458 data->pwm_weight_temp_sel[i] = reg & 0x1f;
1461 data->pwm_weight_temp_sel[i] = 0;
1463 /* Weight temp data */
1464 for (j = 0; j < ARRAY_SIZE(data->weight_temp); j++) {
1465 err = nct6775_read_value(data, data->REG_WEIGHT_TEMP[j][i], ®);
1468 data->weight_temp[j][i] = reg;
1477 struct nct6775_data *data = dev_get_drvdata(dev);
1481 for (i = 0; i < data->pwm_num; i++) {
1482 if (!(data->has_pwm & BIT(i)))
1485 for (j = 0; j < ARRAY_SIZE(data->fan_time); j++) {
1486 err = nct6775_read_value(data, data->REG_FAN_TIME[j][i], ®);
1489 data->fan_time[j][i] = reg;
1492 err = nct6775_read_value(data, data->REG_TARGET[i], ®_t);
1497 if (!data->target_temp[i] ||
1498 data->pwm_enable[i] == thermal_cruise)
1499 data->target_temp[i] = reg_t & data->target_temp_mask;
1500 if (!data->target_speed[i] ||
1501 data->pwm_enable[i] == speed_cruise) {
1502 if (data->REG_TOLERANCE_H) {
1503 err = nct6775_read_value(data, data->REG_TOLERANCE_H[i], ®);
1508 data->target_speed[i] = reg_t;
1511 for (j = 0; j < data->auto_pwm_num; j++) {
1512 err = nct6775_read_value(data, NCT6775_AUTO_PWM(data, i, j), ®);
1515 data->auto_pwm[i][j] = reg;
1517 err = nct6775_read_value(data, NCT6775_AUTO_TEMP(data, i, j), ®);
1520 data->auto_temp[i][j] = reg;
1523 /* critical auto_pwm temperature data */
1524 err = nct6775_read_value(data, data->REG_CRITICAL_TEMP[i], ®);
1527 data->auto_temp[i][data->auto_pwm_num] = reg;
1529 switch (data->kind) {
1531 err = nct6775_read_value(data, NCT6775_REG_CRITICAL_ENAB[i], ®);
1534 data->auto_pwm[i][data->auto_pwm_num] =
1538 data->auto_pwm[i][data->auto_pwm_num] = 0xff;
1551 err = nct6775_read_value(data, data->REG_CRITICAL_PWM_ENABLE[i], ®);
1554 if (reg & data->CRITICAL_PWM_ENABLE_MASK) {
1555 err = nct6775_read_value(data, data->REG_CRITICAL_PWM[i], ®);
1561 data->auto_pwm[i][data->auto_pwm_num] = reg;
1571 struct nct6775_data *data = dev_get_drvdata(dev);
1575 mutex_lock(&data->update_lock);
1577 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1578 || !data->valid) {
1580 err = nct6775_update_fan_div_common(data);
1585 for (i = 0; i < data->in_num; i++) {
1586 if (!(data->have_in & BIT(i)))
1589 err = nct6775_read_value(data, data->REG_VIN[i], ®);
1592 data->in[i][0] = reg;
1594 err = nct6775_read_value(data, data->REG_IN_MINMAX[0][i], ®);
1597 data->in[i][1] = reg;
1599 err = nct6775_read_value(data, data->REG_IN_MINMAX[1][i], ®);
1602 data->in[i][2] = reg;
1606 for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
1607 if (!(data->has_fan & BIT(i)))
1610 err = nct6775_read_value(data, data->REG_FAN[i], ®);
1613 data->rpm[i] = data->fan_from_reg(reg,
1614 data->fan_div[i]);
1616 if (data->has_fan_min & BIT(i)) {
1619 err = nct6775_read_value(data, data->REG_FAN_MIN[i], &tmp);
1622 data->fan_min[i] = tmp;
1625 if (data->REG_FAN_PULSES[i]) {
1628 err = nct6775_read_value(data, data->REG_FAN_PULSES[i], &tmp);
1631 data->fan_pulses[i] = (tmp >> data->FAN_PULSE_SHIFT[i]) & 0x03;
1634 err = nct6775_select_fan_div(dev, data, i, reg);
1649 if (!(data->have_temp & BIT(i)))
1651 for (j = 0; j < ARRAY_SIZE(data->reg_temp); j++) {
1652 if (data->reg_temp[j][i]) {
1653 err = nct6775_read_temp(data, data->reg_temp[j][i], ®);
1656 data->temp[j][i] = reg;
1660 !(data->have_temp_fixed & BIT(i)))
1662 err = nct6775_read_value(data, data->REG_TEMP_OFFSET[i], ®);
1665 data->temp_offset[i] = reg;
1669 if (!(data->have_tsi_temp & BIT(i)))
1671 err = nct6775_read_value(data, data->REG_TSI_TEMP[i], ®);
1674 data->tsi_temp[i] = reg;
1677 data->alarms = 0;
1681 if (!data->REG_ALARM[i])
1683 err = nct6775_read_value(data, data->REG_ALARM[i], &alarm);
1686 data->alarms |= ((u64)alarm) << (i << 3);
1689 data->beeps = 0;
1693 if (!data->REG_BEEP[i])
1695 err = nct6775_read_value(data, data->REG_BEEP[i], &beep);
1698 data->beeps |= ((u64)beep) << (i << 3);
1701 data->last_updated = jiffies;
1702 data->valid = true;
1705 mutex_unlock(&data->update_lock);
1706 return err ? ERR_PTR(err) : data;
1716 struct nct6775_data *data = nct6775_update_device(dev);
1721 if (IS_ERR(data))
1722 return PTR_ERR(data);
1725 in_from_reg(data->in[nr][index], nr, data->scale_in));
1732 struct nct6775_data *data = dev_get_drvdata(dev);
1742 mutex_lock(&data->update_lock);
1743 data->in[nr][index] = in_to_reg(val, nr, data->scale_in);
1744 err = nct6775_write_value(data, data->REG_IN_MINMAX[index - 1][nr], data->in[nr][index]);
1745 mutex_unlock(&data->update_lock);
1752 struct nct6775_data *data = nct6775_update_device(dev);
1756 if (IS_ERR(data))
1757 return PTR_ERR(data);
1759 nr = data->ALARM_BITS[sattr->index];
1761 (unsigned int)((data->alarms >> nr) & 0x01));
1765 static int find_temp_source(struct nct6775_data *data, int index, int count)
1767 int source = data->temp_src[index];
1773 err = nct6775_read_value(data, data->REG_TEMP_SOURCE[nr], &src);
1786 struct nct6775_data *data = nct6775_update_device(dev);
1790 if (IS_ERR(data))
1791 return PTR_ERR(data);
1797 nr = find_temp_source(data, sattr->index, data->num_temp_alarms);
1799 int bit = data->ALARM_BITS[nr + TEMP_ALARM_BASE];
1801 alarm = (data->alarms >> bit) & 0x01;
1810 struct nct6775_data *data = nct6775_update_device(dev);
1813 if (IS_ERR(data))
1814 return PTR_ERR(data);
1816 nr = data->BEEP_BITS[sattr->index];
1819 (unsigned int)((data->beeps >> nr) & 0x01));
1827 struct nct6775_data *data = dev_get_drvdata(dev);
1828 int nr = data->BEEP_BITS[sattr->index];
1839 mutex_lock(&data->update_lock);
1841 data->beeps |= (1ULL << nr);
1843 data->beeps &= ~(1ULL << nr);
1844 err = nct6775_write_value(data, data->REG_BEEP[regindex],
1845 (data->beeps >> (regindex << 3)) & 0xff);
1846 mutex_unlock(&data->update_lock);
1855 struct nct6775_data *data = nct6775_update_device(dev);
1859 if (IS_ERR(data))
1860 return PTR_ERR(data);
1867 nr = find_temp_source(data, sattr->index, data->num_temp_beeps);
1869 int bit = data->BEEP_BITS[nr + TEMP_ALARM_BASE];
1871 beep = (data->beeps >> bit) & 0x01;
1881 struct nct6775_data *data = dev_get_drvdata(dev);
1892 nr = find_temp_source(data, sattr->index, data->num_temp_beeps);
1896 bit = data->BEEP_BITS[nr + TEMP_ALARM_BASE];
1899 mutex_lock(&data->update_lock);
1901 data->beeps |= (1ULL << bit);
1903 data->beeps &= ~(1ULL << bit);
1904 err = nct6775_write_value(data, data->REG_BEEP[regindex],
1905 (data->beeps >> (regindex << 3)) & 0xff);
1906 mutex_unlock(&data->update_lock);
1915 struct nct6775_data *data = dev_get_drvdata(dev);
1919 if (nr == 1 && data->ALARM_BITS[in] == -1)
1922 if (!(data->have_in & BIT(in)))
1925 return nct6775_attr_mode(data, attr);
1956 struct nct6775_data *data = nct6775_update_device(dev);
1960 if (IS_ERR(data))
1961 return PTR_ERR(data);
1963 return sprintf(buf, "%d\n", data->rpm[nr]);
1969 struct nct6775_data *data = nct6775_update_device(dev);
1973 if (IS_ERR(data))
1974 return PTR_ERR(data);
1977 data->fan_from_reg_min(data->fan_min[nr],
1978 data->fan_div[nr]));
1984 struct nct6775_data *data = nct6775_update_device(dev);
1988 if (IS_ERR(data))
1989 return PTR_ERR(data);
1991 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
1998 struct nct6775_data *data = dev_get_drvdata(dev);
2010 mutex_lock(&data->update_lock);
2011 if (!data->has_fan_div) {
2021 data->fan_min[nr] = val;
2026 data->fan_min[nr] = 255;
2027 new_div = data->fan_div[nr]; /* No change */
2037 data->fan_min[nr] = 254;
2041 nr + 1, val, data->fan_from_reg_min(254, 7));
2047 data->fan_min[nr] = 1;
2051 nr + 1, val, data->fan_from_reg_min(1, 0));
2063 data->fan_min[nr] = reg;
2071 if (new_div != data->fan_div[nr]) {
2073 nr + 1, div_from_reg(data->fan_div[nr]),
2075 data->fan_div[nr] = new_div;
2076 err = nct6775_write_fan_div_common(data, nr);
2080 data->last_updated = jiffies;
2084 err = nct6775_write_value(data, data->REG_FAN_MIN[nr], data->fan_min[nr]);
2085 mutex_unlock(&data->update_lock);
2093 struct nct6775_data *data = nct6775_update_device(dev);
2097 if (IS_ERR(data))
2098 return PTR_ERR(data);
2100 p = data->fan_pulses[sattr->index];
2108 struct nct6775_data *data = dev_get_drvdata(dev);
2122 mutex_lock(&data->update_lock);
2123 data->fan_pulses[nr] = val & 3;
2124 err = nct6775_read_value(data, data->REG_FAN_PULSES[nr], ®);
2127 reg &= ~(0x03 << data->FAN_PULSE_SHIFT[nr]);
2128 reg |= (val & 3) << data->FAN_PULSE_SHIFT[nr];
2129 err = nct6775_write_value(data, data->REG_FAN_PULSES[nr], reg);
2131 mutex_unlock(&data->update_lock);
2140 struct nct6775_data *data = dev_get_drvdata(dev);
2144 if (!(data->has_fan & BIT(fan)))
2147 if (nr == 1 && data->ALARM_BITS[FAN_ALARM_BASE + fan] == -1)
2149 if (nr == 2 && data->BEEP_BITS[FAN_ALARM_BASE + fan] == -1)
2151 if (nr == 3 && !data->REG_FAN_PULSES[fan])
2153 if (nr == 4 && !(data->has_fan_min & BIT(fan)))
2155 if (nr == 5 && data->kind != nct6775)
2158 return nct6775_attr_mode(data, attr);
2193 struct nct6775_data *data = nct6775_update_device(dev);
2197 if (IS_ERR(data))
2198 return PTR_ERR(data);
2200 return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
2206 struct nct6775_data *data = nct6775_update_device(dev);
2211 if (IS_ERR(data))
2212 return PTR_ERR(data);
2214 return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->temp[index][nr]));
2221 struct nct6775_data *data = dev_get_drvdata(dev);
2232 mutex_lock(&data->update_lock);
2233 data->temp[index][nr] = LM75_TEMP_TO_REG(val);
2234 err = nct6775_write_temp(data, data->reg_temp[index][nr], data->temp[index][nr]);
2235 mutex_unlock(&data->update_lock);
2242 struct nct6775_data *data = nct6775_update_device(dev);
2245 if (IS_ERR(data))
2246 return PTR_ERR(data);
2248 return sprintf(buf, "%d\n", data->temp_offset[sattr->index] * 1000);
2255 struct nct6775_data *data = dev_get_drvdata(dev);
2267 mutex_lock(&data->update_lock);
2268 data->temp_offset[nr] = val;
2269 err = nct6775_write_value(data, data->REG_TEMP_OFFSET[nr], val);
2270 mutex_unlock(&data->update_lock);
2278 struct nct6775_data *data = nct6775_update_device(dev);
2282 if (IS_ERR(data))
2283 return PTR_ERR(data);
2285 return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
2292 struct nct6775_data *data = nct6775_update_device(dev);
2300 if (IS_ERR(data))
2301 return PTR_ERR(data);
2310 mutex_lock(&data->update_lock);
2312 data->temp_type[nr] = val;
2314 dbit = data->DIODE_MASK << nr;
2316 err = nct6775_read_value(data, data->REG_VBAT, &vbat);
2321 err = nct6775_read_value(data, data->REG_DIODE, &diode);
2337 err = nct6775_write_value(data, data->REG_VBAT, vbat);
2340 err = nct6775_write_value(data, data->REG_DIODE, diode);
2342 mutex_unlock(&data->update_lock);
2350 struct nct6775_data *data = dev_get_drvdata(dev);
2354 if (!(data->have_temp & BIT(temp)))
2357 if (nr == 1 && !data->temp_label)
2360 if (nr == 2 && find_temp_source(data, temp, data->num_temp_alarms) < 0)
2363 if (nr == 3 && find_temp_source(data, temp, data->num_temp_beeps) < 0)
2366 if (nr == 4 && !data->reg_temp[1][temp]) /* max */
2369 if (nr == 5 && !data->reg_temp[2][temp]) /* max_hyst */
2372 if (nr == 6 && !data->reg_temp[3][temp]) /* crit */
2375 if (nr == 7 && !data->reg_temp[4][temp]) /* lcrit */
2379 if (nr > 7 && !(data->have_temp_fixed & BIT(temp)))
2382 return nct6775_attr_mode(data, attr);
2423 struct nct6775_data *data = nct6775_update_device(dev);
2426 if (IS_ERR(data))
2427 return PTR_ERR(data);
2429 return sysfs_emit(buf, "%u\n", tsi_temp_from_reg(data->tsi_temp[sattr->index]));
2446 struct nct6775_data *data = dev_get_drvdata(dev);
2449 return (data->have_tsi_temp & BIT(temp)) ? nct6775_attr_mode(data, attr) : 0;
2465 struct nct6775_data *data = nct6775_update_device(dev);
2468 if (IS_ERR(data))
2469 return PTR_ERR(data);
2471 return sprintf(buf, "%d\n", data->pwm_mode[sattr->index]);
2478 struct nct6775_data *data = dev_get_drvdata(dev);
2493 if (data->REG_PWM_MODE[nr] == 0) {
2499 mutex_lock(&data->update_lock);
2500 data->pwm_mode[nr] = val;
2501 err = nct6775_read_value(data, data->REG_PWM_MODE[nr], ®);
2504 reg &= ~data->PWM_MODE_MASK[nr];
2506 reg |= data->PWM_MODE_MASK[nr];
2507 err = nct6775_write_value(data, data->REG_PWM_MODE[nr], reg);
2509 mutex_unlock(&data->update_lock);
2516 struct nct6775_data *data = nct6775_update_device(dev);
2523 if (IS_ERR(data))
2524 return PTR_ERR(data);
2530 if (index == 0 && data->pwm_enable[nr] > manual) {
2531 err = nct6775_read_value(data, data->REG_PWM_READ[nr], &pwm);
2535 pwm = data->pwm[index][nr];
2545 struct nct6775_data *data = dev_get_drvdata(dev);
2550 int minval[7] = { 0, 1, 1, data->pwm[2][nr], 0, 0, 0 };
2552 = { 255, 255, data->pwm[3][nr] ? : 255, 255, 255, 255, 255 };
2560 if (index == 0 && data->pwm_enable[nr] > manual)
2568 mutex_lock(&data->update_lock);
2569 data->pwm[index][nr] = val;
2570 err = nct6775_write_value(data, data->REG_PWM[index][nr], val);
2574 err = nct6775_read_value(data, data->REG_TEMP_SEL[nr], ®);
2580 err = nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg);
2583 mutex_unlock(&data->update_lock);
2588 static int check_trip_points(struct nct6775_data *data, int nr)
2592 for (i = 0; i < data->auto_pwm_num - 1; i++) {
2593 if (data->auto_temp[nr][i] > data->auto_temp[nr][i + 1])
2596 for (i = 0; i < data->auto_pwm_num - 1; i++) {
2597 if (data->auto_pwm[nr][i] > data->auto_pwm[nr][i + 1])
2601 if (data->auto_pwm[nr][data->auto_pwm_num]) {
2602 if (data->auto_temp[nr][data->auto_pwm_num - 1] >
2603 data->auto_temp[nr][data->auto_pwm_num] ||
2604 data->auto_pwm[nr][data->auto_pwm_num - 1] >
2605 data->auto_pwm[nr][data->auto_pwm_num])
2611 static int pwm_update_registers(struct nct6775_data *data, int nr)
2616 switch (data->pwm_enable[nr]) {
2621 err = nct6775_read_value(data, data->REG_FAN_MODE[nr], ®);
2624 reg = (reg & ~data->tolerance_mask) |
2625 (data->target_speed_tolerance[nr] & data->tolerance_mask);
2626 err = nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2629 err = nct6775_write_value(data, data->REG_TARGET[nr],
2630 data->target_speed[nr] & 0xff);
2633 if (data->REG_TOLERANCE_H) {
2634 reg = (data->target_speed[nr] >> 8) & 0x0f;
2635 reg |= (data->target_speed_tolerance[nr] & 0x38) << 1;
2636 err = nct6775_write_value(data, data->REG_TOLERANCE_H[nr], reg);
2642 err = nct6775_write_value(data, data->REG_TARGET[nr], data->target_temp[nr]);
2647 err = nct6775_read_value(data, data->REG_FAN_MODE[nr], ®);
2650 reg = (reg & ~data->tolerance_mask) |
2651 data->temp_tolerance[0][nr];
2652 err = nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2664 struct nct6775_data *data = nct6775_update_device(dev);
2667 if (IS_ERR(data))
2668 return PTR_ERR(data);
2670 return sprintf(buf, "%d\n", data->pwm_enable[sattr->index]);
2677 struct nct6775_data *data = dev_get_drvdata(dev);
2691 if (val == sf3 && data->kind != nct6775)
2694 if (val == sf4 && check_trip_points(data, nr)) {
2700 mutex_lock(&data->update_lock);
2701 data->pwm_enable[nr] = val;
2706 data->pwm[0][nr] = 255;
2707 err = nct6775_write_value(data, data->REG_PWM[0][nr], 255);
2711 err = pwm_update_registers(data, nr);
2714 err = nct6775_read_value(data, data->REG_FAN_MODE[nr], ®);
2719 err = nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2721 mutex_unlock(&data->update_lock);
2726 show_pwm_temp_sel_common(struct nct6775_data *data, char *buf, int src)
2731 if (!(data->have_temp & BIT(i)))
2733 if (src == data->temp_src[i]) {
2745 struct nct6775_data *data = nct6775_update_device(dev);
2749 if (IS_ERR(data))
2750 return PTR_ERR(data);
2752 return show_pwm_temp_sel_common(data, buf, data->pwm_temp_sel[index]);
2759 struct nct6775_data *data = nct6775_update_device(dev);
2766 if (IS_ERR(data))
2767 return PTR_ERR(data);
2774 if (!(data->have_temp & BIT(val - 1)) || !data->temp_src[val - 1])
2777 mutex_lock(&data->update_lock);
2778 src = data->temp_src[val - 1];
2779 data->pwm_temp_sel[nr] = src;
2780 err = nct6775_read_value(data, data->REG_TEMP_SEL[nr], ®);
2785 err = nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg);
2787 mutex_unlock(&data->update_lock);
2796 struct nct6775_data *data = nct6775_update_device(dev);
2800 if (IS_ERR(data))
2801 return PTR_ERR(data);
2803 return show_pwm_temp_sel_common(data, buf,
2804 data->pwm_weight_temp_sel[index]);
2811 struct nct6775_data *data = nct6775_update_device(dev);
2818 if (IS_ERR(data))
2819 return PTR_ERR(data);
2827 if (val && (!(data->have_temp & BIT(val - 1)) ||
2828 !data->temp_src[val - 1]))
2831 mutex_lock(&data->update_lock);
2833 src = data->temp_src[val - 1];
2834 data->pwm_weight_temp_sel[nr] = src;
2835 err = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr], ®);
2840 err = nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
2842 data->pwm_weight_temp_sel[nr] = 0;
2843 err = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr], ®);
2847 err = nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
2850 mutex_unlock(&data->update_lock);
2858 struct nct6775_data *data = nct6775_update_device(dev);
2861 if (IS_ERR(data))
2862 return PTR_ERR(data);
2864 return sprintf(buf, "%d\n", data->target_temp[sattr->index] * 1000);
2871 struct nct6775_data *data = dev_get_drvdata(dev);
2881 val = DIV_ROUND_CLOSEST(clamp_val(val, 0, data->target_temp_mask * 1000), 1000);
2883 mutex_lock(&data->update_lock);
2884 data->target_temp[nr] = val;
2885 err = pwm_update_registers(data, nr);
2886 mutex_unlock(&data->update_lock);
2893 struct nct6775_data *data = nct6775_update_device(dev);
2897 if (IS_ERR(data))
2898 return PTR_ERR(data);
2901 fan_from_reg16(data->target_speed[nr],
2902 data->fan_div[nr]));
2909 struct nct6775_data *data = dev_get_drvdata(dev);
2921 speed = fan_to_reg(val, data->fan_div[nr]);
2923 mutex_lock(&data->update_lock);
2924 data->target_speed[nr] = speed;
2925 err = pwm_update_registers(data, nr);
2926 mutex_unlock(&data->update_lock);
2934 struct nct6775_data *data = nct6775_update_device(dev);
2939 if (IS_ERR(data))
2940 return PTR_ERR(data);
2942 return sprintf(buf, "%d\n", data->temp_tolerance[index][nr] * 1000);
2949 struct nct6775_data *data = dev_get_drvdata(dev);
2961 val = DIV_ROUND_CLOSEST(clamp_val(val, 0, data->tolerance_mask * 1000), 1000);
2963 mutex_lock(&data->update_lock);
2964 data->temp_tolerance[index][nr] = val;
2966 err = pwm_update_registers(data, nr);
2968 err = nct6775_write_value(data, data->REG_CRITICAL_TEMP_TOLERANCE[nr], val);
2969 mutex_unlock(&data->update_lock);
2984 struct nct6775_data *data = nct6775_update_device(dev);
2989 if (IS_ERR(data))
2990 return PTR_ERR(data);
2992 target = data->target_speed[nr];
2995 int low = target - data->target_speed_tolerance[nr];
2996 int high = target + data->target_speed_tolerance[nr];
3005 tolerance = (fan_from_reg16(low, data->fan_div[nr])
3006 - fan_from_reg16(high, data->fan_div[nr])) / 2;
3016 struct nct6775_data *data = dev_get_drvdata(dev);
3027 high = fan_from_reg16(data->target_speed[nr], data->fan_div[nr]) + val;
3028 low = fan_from_reg16(data->target_speed[nr], data->fan_div[nr]) - val;
3034 val = (fan_to_reg(low, data->fan_div[nr]) -
3035 fan_to_reg(high, data->fan_div[nr])) / 2;
3038 val = clamp_val(val, 0, data->speed_tolerance_limit);
3040 mutex_lock(&data->update_lock);
3041 data->target_speed_tolerance[nr] = val;
3042 err = pwm_update_registers(data, nr);
3043 mutex_unlock(&data->update_lock);
3061 struct nct6775_data *data = nct6775_update_device(dev);
3066 if (IS_ERR(data))
3067 return PTR_ERR(data);
3069 return sprintf(buf, "%d\n", data->weight_temp[index][nr] * 1000);
3076 struct nct6775_data *data = dev_get_drvdata(dev);
3089 mutex_lock(&data->update_lock);
3090 data->weight_temp[index][nr] = val;
3091 err = nct6775_write_value(data, data->REG_WEIGHT_TEMP[index][nr], val);
3092 mutex_unlock(&data->update_lock);
3110 struct nct6775_data *data = nct6775_update_device(dev);
3115 if (IS_ERR(data))
3116 return PTR_ERR(data);
3119 step_time_from_reg(data->fan_time[index][nr],
3120 data->pwm_mode[nr]));
3127 struct nct6775_data *data = dev_get_drvdata(dev);
3138 val = step_time_to_reg(val, data->pwm_mode[nr]);
3139 mutex_lock(&data->update_lock);
3140 data->fan_time[index][nr] = val;
3141 err = nct6775_write_value(data, data->REG_FAN_TIME[index][nr], val);
3142 mutex_unlock(&data->update_lock);
3149 struct nct6775_data *data = nct6775_update_device(dev);
3152 if (IS_ERR(data))
3153 return PTR_ERR(data);
3155 return sprintf(buf, "%d\n", data->auto_pwm[sattr->nr][sattr->index]);
3162 struct nct6775_data *data = dev_get_drvdata(dev);
3176 if (point == data->auto_pwm_num) {
3177 if (data->kind != nct6775 && !val)
3179 if (data->kind != nct6779 && val)
3183 mutex_lock(&data->update_lock);
3184 data->auto_pwm[nr][point] = val;
3185 if (point < data->auto_pwm_num) {
3186 err = nct6775_write_value(data, NCT6775_AUTO_PWM(data, nr, point),
3187 data->auto_pwm[nr][point]);
3189 switch (data->kind) {
3192 err = nct6775_read_value(data, NCT6775_REG_CRITICAL_ENAB[nr], ®);
3199 err = nct6775_write_value(data, NCT6775_REG_CRITICAL_ENAB[nr], reg);
3214 err = nct6775_write_value(data, data->REG_CRITICAL_PWM[nr], val);
3217 err = nct6775_read_value(data, data->REG_CRITICAL_PWM_ENABLE[nr], ®);
3221 reg &= ~data->CRITICAL_PWM_ENABLE_MASK;
3223 reg |= data->CRITICAL_PWM_ENABLE_MASK;
3224 err = nct6775_write_value(data, data->REG_CRITICAL_PWM_ENABLE[nr], reg);
3228 mutex_unlock(&data->update_lock);
3235 struct nct6775_data *data = nct6775_update_device(dev);
3240 if (IS_ERR(data))
3241 return PTR_ERR(data);
3247 return sprintf(buf, "%d\n", data->auto_temp[nr][point] * 1000);
3254 struct nct6775_data *data = dev_get_drvdata(dev);
3267 mutex_lock(&data->update_lock);
3268 data->auto_temp[nr][point] = DIV_ROUND_CLOSEST(val, 1000);
3269 if (point < data->auto_pwm_num) {
3270 err = nct6775_write_value(data, NCT6775_AUTO_TEMP(data, nr, point),
3271 data->auto_temp[nr][point]);
3273 err = nct6775_write_value(data, data->REG_CRITICAL_TEMP[nr],
3274 data->auto_temp[nr][point]);
3276 mutex_unlock(&data->update_lock);
3284 struct nct6775_data *data = dev_get_drvdata(dev);
3288 if (!(data->has_pwm & BIT(pwm)))
3292 if (!data->REG_WEIGHT_TEMP_SEL[pwm])
3294 if (nr == 19 && data->REG_PWM[3] == NULL) /* pwm_max */
3296 if (nr == 20 && data->REG_PWM[4] == NULL) /* pwm_step */
3298 if (nr == 21 && data->REG_PWM[6] == NULL) /* weight_duty_base */
3304 if (api > data->auto_pwm_num)
3307 return nct6775_attr_mode(data, attr);
3413 static inline int nct6775_init_device(struct nct6775_data *data)
3419 if (data->REG_CONFIG) {
3420 err = nct6775_read_value(data, data->REG_CONFIG, &tmp);
3424 err = nct6775_write_value(data, data->REG_CONFIG, tmp | 0x01);
3432 if (!(data->have_temp & BIT(i)))
3434 if (!data->reg_temp_config[i])
3436 err = nct6775_read_value(data, data->reg_temp_config[i], &tmp);
3440 err = nct6775_write_value(data, data->reg_temp_config[i], tmp & 0xfe);
3447 err = nct6775_read_value(data, data->REG_VBAT, &tmp);
3451 err = nct6775_write_value(data, data->REG_VBAT, tmp | 0x01);
3456 err = nct6775_read_value(data, data->REG_DIODE, &diode);
3460 for (i = 0; i < data->temp_fixed_num; i++) {
3461 if (!(data->have_temp_fixed & BIT(i)))
3463 if ((tmp & (data->DIODE_MASK << i))) /* diode */
3464 data->temp_type[i]
3465 = 3 - ((diode >> i) & data->DIODE_MASK);
3467 data->temp_type[i] = 4;
3473 static int add_temp_sensors(struct nct6775_data *data, const u16 *regp,
3479 for (i = 0; i < data->pwm_num && *available; i++) {
3484 err = nct6775_read_value(data, regp[i], &src);
3490 if (!(data->temp_mask & BIT(src)))
3494 err = nct6775_write_value(data, data->REG_TEMP_SOURCE[index], src);
3504 int nct6775_probe(struct device *dev, struct nct6775_data *data,
3518 data->regmap = devm_regmap_init(dev, NULL, data, regmapcfg);
3519 if (IS_ERR(data->regmap))
3520 return PTR_ERR(data->regmap);
3522 mutex_init(&data->update_lock);
3523 data->name = nct6775_device_names[data->kind];
3524 data->bank = 0xff; /* Force initial bank selection */
3525 data->scale_in = scale_in;
3527 switch (data->kind) {
3529 data->in_num = 9;
3530 data->pwm_num = 3;
3531 data->auto_pwm_num = 4;
3532 data->temp_fixed_num = 3;
3533 data->num_temp_alarms = 6;
3534 data->num_temp_beeps = 6;
3536 data->fan_from_reg = fan_from_reg13;
3537 data->fan_from_reg_min = fan_from_reg13;
3539 data->temp_label = nct6776_temp_label;
3540 data->temp_mask = NCT6776_TEMP_MASK;
3541 data->virt_temp_mask = NCT6776_VIRT_TEMP_MASK;
3543 data->REG_VBAT = NCT6106_REG_VBAT;
3544 data->REG_DIODE = NCT6106_REG_DIODE;
3545 data->DIODE_MASK = NCT6106_DIODE_MASK;
3546 data->REG_VIN = NCT6106_REG_IN;
3547 data->REG_IN_MINMAX[0] = NCT6106_REG_IN_MIN;
3548 data->REG_IN_MINMAX[1] = NCT6106_REG_IN_MAX;
3549 data->REG_TARGET = NCT6106_REG_TARGET;
3550 data->REG_FAN = NCT6106_REG_FAN;
3551 data->REG_FAN_MODE = NCT6106_REG_FAN_MODE;
3552 data->REG_FAN_MIN = NCT6106_REG_FAN_MIN;
3553 data->REG_FAN_PULSES = NCT6106_REG_FAN_PULSES;
3554 data->FAN_PULSE_SHIFT = NCT6106_FAN_PULSE_SHIFT;
3555 data->REG_FAN_TIME[0] = NCT6106_REG_FAN_STOP_TIME;
3556 data->REG_FAN_TIME[1] = NCT6106_REG_FAN_STEP_UP_TIME;
3557 data->REG_FAN_TIME[2] = NCT6106_REG_FAN_STEP_DOWN_TIME;
3558 data->REG_TOLERANCE_H = NCT6106_REG_TOLERANCE_H;
3559 data->REG_PWM[0] = NCT6116_REG_PWM;
3560 data->REG_PWM[1] = NCT6106_REG_FAN_START_OUTPUT;
3561 data->REG_PWM[2] = NCT6106_REG_FAN_STOP_OUTPUT;
3562 data->REG_PWM[5] = NCT6106_REG_WEIGHT_DUTY_STEP;
3563 data->REG_PWM[6] = NCT6106_REG_WEIGHT_DUTY_BASE;
3564 data->REG_PWM_READ = NCT6106_REG_PWM_READ;
3565 data->REG_PWM_MODE = NCT6106_REG_PWM_MODE;
3566 data->PWM_MODE_MASK = NCT6106_PWM_MODE_MASK;
3567 data->REG_AUTO_TEMP = NCT6106_REG_AUTO_TEMP;
3568 data->REG_AUTO_PWM = NCT6106_REG_AUTO_PWM;
3569 data->REG_CRITICAL_TEMP = NCT6106_REG_CRITICAL_TEMP;
3570 data->REG_CRITICAL_TEMP_TOLERANCE
3572 data->REG_CRITICAL_PWM_ENABLE = NCT6106_REG_CRITICAL_PWM_ENABLE;
3573 data->CRITICAL_PWM_ENABLE_MASK
3575 data->REG_CRITICAL_PWM = NCT6106_REG_CRITICAL_PWM;
3576 data->REG_TEMP_OFFSET = NCT6106_REG_TEMP_OFFSET;
3577 data->REG_TEMP_SOURCE = NCT6106_REG_TEMP_SOURCE;
3578 data->REG_TEMP_SEL = NCT6116_REG_TEMP_SEL;
3579 data->REG_WEIGHT_TEMP_SEL = NCT6106_REG_WEIGHT_TEMP_SEL;
3580 data->REG_WEIGHT_TEMP[0] = NCT6106_REG_WEIGHT_TEMP_STEP;
3581 data->REG_WEIGHT_TEMP[1] = NCT6106_REG_WEIGHT_TEMP_STEP_TOL;
3582 data->REG_WEIGHT_TEMP[2] = NCT6106_REG_WEIGHT_TEMP_BASE;
3583 data->REG_ALARM = NCT6106_REG_ALARM;
3584 data->ALARM_BITS = NCT6106_ALARM_BITS;
3585 data->REG_BEEP = NCT6106_REG_BEEP;
3586 data->BEEP_BITS = NCT6106_BEEP_BITS;
3587 data->REG_TSI_TEMP = NCT6106_REG_TSI_TEMP;
3605 data->in_num = 9;
3606 data->pwm_num = 3;
3607 data->auto_pwm_num = 4;
3608 data->temp_fixed_num = 3;
3609 data->num_temp_alarms = 3;
3610 data->num_temp_beeps = 3;
3612 data->fan_from_reg = fan_from_reg13;
3613 data->fan_from_reg_min = fan_from_reg13;
3615 data->temp_label = nct6776_temp_label;
3616 data->temp_mask = NCT6776_TEMP_MASK;
3617 data->virt_temp_mask = NCT6776_VIRT_TEMP_MASK;
3619 data->REG_VBAT = NCT6106_REG_VBAT;
3620 data->REG_DIODE = NCT6106_REG_DIODE;
3621 data->DIODE_MASK = NCT6106_DIODE_MASK;
3622 data->REG_VIN = NCT6106_REG_IN;
3623 data->REG_IN_MINMAX[0] = NCT6106_REG_IN_MIN;
3624 data->REG_IN_MINMAX[1] = NCT6106_REG_IN_MAX;
3625 data->REG_TARGET = NCT6116_REG_TARGET;
3626 data->REG_FAN = NCT6116_REG_FAN;
3627 data->REG_FAN_MODE = NCT6116_REG_FAN_MODE;
3628 data->REG_FAN_MIN = NCT6116_REG_FAN_MIN;
3629 data->REG_FAN_PULSES = NCT6116_REG_FAN_PULSES;
3630 data->FAN_PULSE_SHIFT = NCT6116_FAN_PULSE_SHIFT;
3631 data->REG_FAN_TIME[0] = NCT6116_REG_FAN_STOP_TIME;
3632 data->REG_FAN_TIME[1] = NCT6116_REG_FAN_STEP_UP_TIME;
3633 data->REG_FAN_TIME[2] = NCT6116_REG_FAN_STEP_DOWN_TIME;
3634 data->REG_TOLERANCE_H = NCT6116_REG_TOLERANCE_H;
3635 data->REG_PWM[0] = NCT6116_REG_PWM;
3636 data->REG_PWM[1] = NCT6116_REG_FAN_START_OUTPUT;
3637 data->REG_PWM[2] = NCT6116_REG_FAN_STOP_OUTPUT;
3638 data->REG_PWM[5] = NCT6106_REG_WEIGHT_DUTY_STEP;
3639 data->REG_PWM[6] = NCT6106_REG_WEIGHT_DUTY_BASE;
3640 data->REG_PWM_READ = NCT6106_REG_PWM_READ;
3641 data->REG_PWM_MODE = NCT6106_REG_PWM_MODE;
3642 data->PWM_MODE_MASK = NCT6106_PWM_MODE_MASK;
3643 data->REG_AUTO_TEMP = NCT6116_REG_AUTO_TEMP;
3644 data->REG_AUTO_PWM = NCT6116_REG_AUTO_PWM;
3645 data->REG_CRITICAL_TEMP = NCT6116_REG_CRITICAL_TEMP;
3646 data->REG_CRITICAL_TEMP_TOLERANCE
3648 data->REG_CRITICAL_PWM_ENABLE = NCT6116_REG_CRITICAL_PWM_ENABLE;
3649 data->CRITICAL_PWM_ENABLE_MASK
3651 data->REG_CRITICAL_PWM = NCT6116_REG_CRITICAL_PWM;
3652 data->REG_TEMP_OFFSET = NCT6106_REG_TEMP_OFFSET;
3653 data->REG_TEMP_SOURCE = NCT6116_REG_TEMP_SOURCE;
3654 data->REG_TEMP_SEL = NCT6116_REG_TEMP_SEL;
3655 data->REG_WEIGHT_TEMP_SEL = NCT6106_REG_WEIGHT_TEMP_SEL;
3656 data->REG_WEIGHT_TEMP[0] = NCT6106_REG_WEIGHT_TEMP_STEP;
3657 data->REG_WEIGHT_TEMP[1] = NCT6106_REG_WEIGHT_TEMP_STEP_TOL;
3658 data->REG_WEIGHT_TEMP[2] = NCT6106_REG_WEIGHT_TEMP_BASE;
3659 data->REG_ALARM = NCT6106_REG_ALARM;
3660 data->ALARM_BITS = NCT6116_ALARM_BITS;
3661 data->REG_BEEP = NCT6106_REG_BEEP;
3662 data->BEEP_BITS = NCT6116_BEEP_BITS;
3663 data->REG_TSI_TEMP = NCT6116_REG_TSI_TEMP;
3681 data->in_num = 9;
3682 data->pwm_num = 3;
3683 data->auto_pwm_num = 6;
3684 data->has_fan_div = true;
3685 data->temp_fixed_num = 3;
3686 data->num_temp_alarms = 3;
3687 data->num_temp_beeps = 3;
3689 data->ALARM_BITS = NCT6775_ALARM_BITS;
3690 data->BEEP_BITS = NCT6775_BEEP_BITS;
3692 data->fan_from_reg = fan_from_reg16;
3693 data->fan_from_reg_min = fan_from_reg8;
3694 data->target_temp_mask = 0x7f;
3695 data->tolerance_mask = 0x0f;
3696 data->speed_tolerance_limit = 15;
3698 data->temp_label = nct6775_temp_label;
3699 data->temp_mask = NCT6775_TEMP_MASK;
3700 data->virt_temp_mask = NCT6775_VIRT_TEMP_MASK;
3702 data->REG_CONFIG = NCT6775_REG_CONFIG;
3703 data->REG_VBAT = NCT6775_REG_VBAT;
3704 data->REG_DIODE = NCT6775_REG_DIODE;
3705 data->DIODE_MASK = NCT6775_DIODE_MASK;
3706 data->REG_VIN = NCT6775_REG_IN;
3707 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3708 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3709 data->REG_TARGET = NCT6775_REG_TARGET;
3710 data->REG_FAN = NCT6775_REG_FAN;
3711 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3712 data->REG_FAN_MIN = NCT6775_REG_FAN_MIN;
3713 data->REG_FAN_PULSES = NCT6775_REG_FAN_PULSES;
3714 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3715 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3716 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
3717 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
3718 data->REG_PWM[0] = NCT6775_REG_PWM;
3719 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3720 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3721 data->REG_PWM[3] = NCT6775_REG_FAN_MAX_OUTPUT;
3722 data->REG_PWM[4] = NCT6775_REG_FAN_STEP_OUTPUT;
3723 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
3724 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3725 data->REG_PWM_MODE = NCT6775_REG_PWM_MODE;
3726 data->PWM_MODE_MASK = NCT6775_PWM_MODE_MASK;
3727 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3728 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3729 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3730 data->REG_CRITICAL_TEMP_TOLERANCE
3732 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
3733 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3734 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
3735 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
3736 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3737 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3738 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3739 data->REG_ALARM = NCT6775_REG_ALARM;
3740 data->REG_BEEP = NCT6775_REG_BEEP;
3741 data->REG_TSI_TEMP = NCT6775_REG_TSI_TEMP;
3757 data->in_num = 9;
3758 data->pwm_num = 3;
3759 data->auto_pwm_num = 4;
3760 data->has_fan_div = false;
3761 data->temp_fixed_num = 3;
3762 data->num_temp_alarms = 3;
3763 data->num_temp_beeps = 6;
3765 data->ALARM_BITS = NCT6776_ALARM_BITS;
3766 data->BEEP_BITS = NCT6776_BEEP_BITS;
3768 data->fan_from_reg = fan_from_reg13;
3769 data->fan_from_reg_min = fan_from_reg13;
3770 data->target_temp_mask = 0xff;
3771 data->tolerance_mask = 0x07;
3772 data->speed_tolerance_limit = 63;
3774 data->temp_label = nct6776_temp_label;
3775 data->temp_mask = NCT6776_TEMP_MASK;
3776 data->virt_temp_mask = NCT6776_VIRT_TEMP_MASK;
3778 data->REG_CONFIG = NCT6775_REG_CONFIG;
3779 data->REG_VBAT = NCT6775_REG_VBAT;
3780 data->REG_DIODE = NCT6775_REG_DIODE;
3781 data->DIODE_MASK = NCT6775_DIODE_MASK;
3782 data->REG_VIN = NCT6775_REG_IN;
3783 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3784 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3785 data->REG_TARGET = NCT6775_REG_TARGET;
3786 data->REG_FAN = NCT6775_REG_FAN;
3787 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3788 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3789 data->REG_FAN_PULSES = NCT6776_REG_FAN_PULSES;
3790 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3791 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3792 data->REG_FAN_TIME[1] = NCT6776_REG_FAN_STEP_UP_TIME;
3793 data->REG_FAN_TIME[2] = NCT6776_REG_FAN_STEP_DOWN_TIME;
3794 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
3795 data->REG_PWM[0] = NCT6775_REG_PWM;
3796 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3797 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3798 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
3799 data->REG_PWM[6] = NCT6776_REG_WEIGHT_DUTY_BASE;
3800 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3801 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3802 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3803 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3804 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3805 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3806 data->REG_CRITICAL_TEMP_TOLERANCE
3808 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
3809 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3810 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
3811 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
3812 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3813 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3814 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3815 data->REG_ALARM = NCT6775_REG_ALARM;
3816 data->REG_BEEP = NCT6776_REG_BEEP;
3817 data->REG_TSI_TEMP = NCT6776_REG_TSI_TEMP;
3833 data->in_num = 15;
3834 data->pwm_num = 5;
3835 data->auto_pwm_num = 4;
3836 data->has_fan_div = false;
3837 data->temp_fixed_num = 6;
3838 data->num_temp_alarms = 2;
3839 data->num_temp_beeps = 2;
3841 data->ALARM_BITS = NCT6779_ALARM_BITS;
3842 data->BEEP_BITS = NCT6779_BEEP_BITS;
3844 data->fan_from_reg = fan_from_reg_rpm;
3845 data->fan_from_reg_min = fan_from_reg13;
3846 data->target_temp_mask = 0xff;
3847 data->tolerance_mask = 0x07;
3848 data->speed_tolerance_limit = 63;
3850 data->temp_label = nct6779_temp_label;
3851 data->temp_mask = NCT6779_TEMP_MASK;
3852 data->virt_temp_mask = NCT6779_VIRT_TEMP_MASK;
3854 data->REG_CONFIG = NCT6775_REG_CONFIG;
3855 data->REG_VBAT = NCT6775_REG_VBAT;
3856 data->REG_DIODE = NCT6775_REG_DIODE;
3857 data->DIODE_MASK = NCT6775_DIODE_MASK;
3858 data->REG_VIN = NCT6779_REG_IN;
3859 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3860 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3861 data->REG_TARGET = NCT6775_REG_TARGET;
3862 data->REG_FAN = NCT6779_REG_FAN;
3863 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3864 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3865 data->REG_FAN_PULSES = NCT6779_REG_FAN_PULSES;
3866 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3867 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3868 data->REG_FAN_TIME[1] = NCT6776_REG_FAN_STEP_UP_TIME;
3869 data->REG_FAN_TIME[2] = NCT6776_REG_FAN_STEP_DOWN_TIME;
3870 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
3871 data->REG_PWM[0] = NCT6775_REG_PWM;
3872 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3873 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3874 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
3875 data->REG_PWM[6] = NCT6776_REG_WEIGHT_DUTY_BASE;
3876 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3877 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3878 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3879 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3880 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3881 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3882 data->REG_CRITICAL_TEMP_TOLERANCE
3884 data->REG_CRITICAL_PWM_ENABLE = NCT6779_REG_CRITICAL_PWM_ENABLE;
3885 data->CRITICAL_PWM_ENABLE_MASK
3887 data->REG_CRITICAL_PWM = NCT6779_REG_CRITICAL_PWM;
3888 data->REG_TEMP_OFFSET = NCT6779_REG_TEMP_OFFSET;
3889 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
3890 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
3891 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
3892 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
3893 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
3894 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
3895 data->REG_ALARM = NCT6779_REG_ALARM;
3896 data->REG_BEEP = NCT6776_REG_BEEP;
3897 data->REG_TSI_TEMP = NCT6776_REG_TSI_TEMP;
3918 data->in_num = 15;
3919 data->pwm_num = (data->kind == nct6796 ||
3920 data->kind == nct6797) ? 7 : 6;
3921 data->auto_pwm_num = 4;
3922 data->has_fan_div = false;
3923 data->temp_fixed_num = 6;
3924 data->num_temp_alarms = 2;
3925 data->num_temp_beeps = 2;
3927 data->ALARM_BITS = NCT6791_ALARM_BITS;
3928 data->BEEP_BITS = NCT6779_BEEP_BITS;
3930 data->fan_from_reg = fan_from_reg_rpm;
3931 data->fan_from_reg_min = fan_from_reg13;
3932 data->target_temp_mask = 0xff;
3933 data->tolerance_mask = 0x07;
3934 data->speed_tolerance_limit = 63;
3936 switch (data->kind) {
3939 data->temp_label = nct6779_temp_label;
3940 data->temp_mask = NCT6791_TEMP_MASK;
3941 data->virt_temp_mask = NCT6791_VIRT_TEMP_MASK;
3944 data->temp_label = nct6792_temp_label;
3945 data->temp_mask = NCT6792_TEMP_MASK;
3946 data->virt_temp_mask = NCT6792_VIRT_TEMP_MASK;
3949 data->temp_label = nct6793_temp_label;
3950 data->temp_mask = NCT6793_TEMP_MASK;
3951 data->virt_temp_mask = NCT6793_VIRT_TEMP_MASK;
3955 data->temp_label = nct6795_temp_label;
3956 data->temp_mask = NCT6795_TEMP_MASK;
3957 data->virt_temp_mask = NCT6795_VIRT_TEMP_MASK;
3960 data->temp_label = nct6796_temp_label;
3961 data->temp_mask = NCT6796_TEMP_MASK;
3962 data->virt_temp_mask = NCT6796_VIRT_TEMP_MASK;
3966 data->REG_CONFIG = NCT6775_REG_CONFIG;
3967 data->REG_VBAT = NCT6775_REG_VBAT;
3968 data->REG_DIODE = NCT6775_REG_DIODE;
3969 data->DIODE_MASK = NCT6775_DIODE_MASK;
3970 data->REG_VIN = NCT6779_REG_IN;
3971 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
3972 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
3973 data->REG_TARGET = NCT6775_REG_TARGET;
3974 data->REG_FAN = NCT6779_REG_FAN;
3975 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
3976 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
3977 data->REG_FAN_PULSES = NCT6779_REG_FAN_PULSES;
3978 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
3979 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
3980 data->REG_FAN_TIME[1] = NCT6776_REG_FAN_STEP_UP_TIME;
3981 data->REG_FAN_TIME[2] = NCT6776_REG_FAN_STEP_DOWN_TIME;
3982 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
3983 data->REG_PWM[0] = NCT6775_REG_PWM;
3984 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
3985 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
3986 data->REG_PWM[5] = NCT6791_REG_WEIGHT_DUTY_STEP;
3987 data->REG_PWM[6] = NCT6791_REG_WEIGHT_DUTY_BASE;
3988 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
3989 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
3990 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
3991 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
3992 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
3993 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
3994 data->REG_CRITICAL_TEMP_TOLERANCE
3996 data->REG_CRITICAL_PWM_ENABLE = NCT6779_REG_CRITICAL_PWM_ENABLE;
3997 data->CRITICAL_PWM_ENABLE_MASK
3999 data->REG_CRITICAL_PWM = NCT6779_REG_CRITICAL_PWM;
4000 data->REG_TEMP_OFFSET = NCT6779_REG_TEMP_OFFSET;
4001 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
4002 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
4003 data->REG_WEIGHT_TEMP_SEL = NCT6791_REG_WEIGHT_TEMP_SEL;
4004 data->REG_WEIGHT_TEMP[0] = NCT6791_REG_WEIGHT_TEMP_STEP;
4005 data->REG_WEIGHT_TEMP[1] = NCT6791_REG_WEIGHT_TEMP_STEP_TOL;
4006 data->REG_WEIGHT_TEMP[2] = NCT6791_REG_WEIGHT_TEMP_BASE;
4007 data->REG_ALARM = NCT6791_REG_ALARM;
4008 if (data->kind == nct6791)
4009 data->REG_BEEP = NCT6776_REG_BEEP;
4011 data->REG_BEEP = NCT6792_REG_BEEP;
4012 switch (data->kind) {
4016 data->REG_TSI_TEMP = NCT6776_REG_TSI_TEMP;
4022 data->REG_TSI_TEMP = NCT6796_REG_TSI_TEMP;
4032 if (data->kind == nct6791) {
4049 data->in_num = data->kind == nct6799 ? 18 : 15;
4050 data->scale_in = scale_in_6798;
4051 data->pwm_num = 7;
4052 data->auto_pwm_num = 4;
4053 data->has_fan_div = false;
4054 data->temp_fixed_num = 6;
4055 data->num_temp_alarms = 7;
4056 data->num_temp_beeps = 8;
4058 data->ALARM_BITS = NCT6799_ALARM_BITS;
4059 data->BEEP_BITS = NCT6799_BEEP_BITS;
4061 data->fan_from_reg = fan_from_reg_rpm;
4062 data->fan_from_reg_min = fan_from_reg13;
4063 data->target_temp_mask = 0xff;
4064 data->tolerance_mask = 0x07;
4065 data->speed_tolerance_limit = 63;
4067 switch (data->kind) {
4070 data->temp_label = nct6798_temp_label;
4071 data->temp_mask = NCT6798_TEMP_MASK;
4072 data->virt_temp_mask = NCT6798_VIRT_TEMP_MASK;
4075 data->temp_label = nct6799_temp_label;
4076 data->temp_mask = NCT6799_TEMP_MASK;
4077 data->virt_temp_mask = NCT6799_VIRT_TEMP_MASK;
4081 data->REG_CONFIG = NCT6775_REG_CONFIG;
4082 data->REG_VBAT = NCT6775_REG_VBAT;
4083 data->REG_DIODE = NCT6775_REG_DIODE;
4084 data->DIODE_MASK = NCT6775_DIODE_MASK;
4085 data->REG_VIN = NCT6779_REG_IN;
4086 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
4087 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
4088 data->REG_TARGET = NCT6775_REG_TARGET;
4089 data->REG_FAN = NCT6779_REG_FAN;
4090 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
4091 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
4092 data->REG_FAN_PULSES = NCT6779_REG_FAN_PULSES;
4093 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
4094 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
4095 data->REG_FAN_TIME[1] = NCT6776_REG_FAN_STEP_UP_TIME;
4096 data->REG_FAN_TIME[2] = NCT6776_REG_FAN_STEP_DOWN_TIME;
4097 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
4098 data->REG_PWM[0] = NCT6775_REG_PWM;
4099 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
4100 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
4101 data->REG_PWM[5] = NCT6791_REG_WEIGHT_DUTY_STEP;
4102 data->REG_PWM[6] = NCT6791_REG_WEIGHT_DUTY_BASE;
4103 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
4104 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
4105 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
4106 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
4107 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
4108 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
4109 data->REG_CRITICAL_TEMP_TOLERANCE = NCT6775_REG_CRITICAL_TEMP_TOLERANCE;
4110 data->REG_CRITICAL_PWM_ENABLE = NCT6779_REG_CRITICAL_PWM_ENABLE;
4111 data->CRITICAL_PWM_ENABLE_MASK = NCT6779_CRITICAL_PWM_ENABLE_MASK;
4112 data->REG_CRITICAL_PWM = NCT6779_REG_CRITICAL_PWM;
4113 data->REG_TEMP_OFFSET = NCT6779_REG_TEMP_OFFSET;
4114 data->REG_TEMP_SOURCE = NCT6798_REG_TEMP_SOURCE;
4115 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
4116 data->REG_WEIGHT_TEMP_SEL = NCT6791_REG_WEIGHT_TEMP_SEL;
4117 data->REG_WEIGHT_TEMP[0] = NCT6791_REG_WEIGHT_TEMP_STEP;
4118 data->REG_WEIGHT_TEMP[1] = NCT6791_REG_WEIGHT_TEMP_STEP_TOL;
4119 data->REG_WEIGHT_TEMP[2] = NCT6791_REG_WEIGHT_TEMP_BASE;
4120 data->REG_ALARM = NCT6799_REG_ALARM;
4121 data->REG_BEEP = NCT6792_REG_BEEP;
4122 data->REG_TSI_TEMP = NCT6796_REG_TSI_TEMP;
4140 data->have_in = BIT(data->in_num) - 1;
4141 data->have_temp = 0;
4157 err = nct6775_read_value(data, data->REG_TEMP_SOURCE[i], &src);
4171 err = add_temp_sensors(data, data->REG_TEMP_SEL, &available, &mask);
4174 err = add_temp_sensors(data, data->REG_WEIGHT_TEMP_SEL, &available, &mask);
4184 err = nct6775_read_value(data, data->REG_TEMP_SOURCE[i], &src);
4191 if (!(data->temp_mask & BIT(src))) {
4194 src, i, data->REG_TEMP_SOURCE[i], reg_temp[i]);
4201 if (src <= data->temp_fixed_num) {
4202 data->have_temp |= BIT(src - 1);
4203 data->have_temp_fixed |= BIT(src - 1);
4204 data->reg_temp[0][src - 1] = reg_temp[i];
4205 data->reg_temp[1][src - 1] = reg_temp_over[i];
4206 data->reg_temp[2][src - 1] = reg_temp_hyst[i];
4208 data->reg_temp[3][src - 1] = reg_temp_crit_h[i];
4210 data->reg_temp[3][src - 1]
4213 data->reg_temp[4][src - 1] = reg_temp_crit_l[i];
4215 data->reg_temp_config[src - 1] = reg_temp_config[i];
4216 data->temp_src[src - 1] = src;
4224 data->have_temp |= BIT(s);
4225 data->reg_temp[0][s] = reg_temp[i];
4226 data->reg_temp[1][s] = reg_temp_over[i];
4227 data->reg_temp[2][s] = reg_temp_hyst[i];
4229 data->reg_temp_config[s] = reg_temp_config[i];
4231 data->reg_temp[3][s] = reg_temp_crit_h[i];
4233 data->reg_temp[3][s] = reg_temp_crit[src - 1];
4235 data->reg_temp[4][s] = reg_temp_crit_l[i];
4237 data->temp_src[s] = src;
4249 err = nct6775_read_value(data, data->REG_TEMP_SEL[i], &src);
4256 if (!(data->temp_mask & BIT(src))) {
4259 src, i, data->REG_TEMP_SEL[i],
4269 if (!(data->virt_temp_mask & BIT(src))) {
4276 if (src <= data->temp_fixed_num) {
4277 if (data->have_temp & BIT(src - 1))
4279 data->have_temp |= BIT(src - 1);
4280 data->have_temp_fixed |= BIT(src - 1);
4281 data->reg_temp[0][src - 1] = reg_temp_mon[i];
4282 data->temp_src[src - 1] = src;
4290 data->have_temp |= BIT(s);
4291 data->reg_temp[0][s] = reg_temp_mon[i];
4292 data->temp_src[s] = src;
4304 if (!(data->temp_mask & BIT(i + 1)))
4310 if (i < data->temp_fixed_num) {
4311 if (data->have_temp & BIT(i))
4313 data->have_temp |= BIT(i);
4314 data->have_temp_fixed |= BIT(i);
4315 data->reg_temp[0][i] = reg_temp_alternate[i];
4317 data->reg_temp[1][i] = reg_temp_over[i];
4318 data->reg_temp[2][i] = reg_temp_hyst[i];
4320 data->temp_src[i] = i + 1;
4327 data->have_temp |= BIT(s);
4328 data->reg_temp[0][s] = reg_temp_alternate[i];
4329 data->temp_src[s] = i + 1;
4338 err = nct6775_read_value(data, data->REG_TSI_TEMP[i], &tmp);
4342 data->have_tsi_temp |= BIT(i);
4346 err = nct6775_init_device(data);
4350 if (data->driver_init) {
4351 err = data->driver_init(data);
4357 err = nct6775_init_fan_common(dev, data);
4362 err = nct6775_add_template_attr_group(dev, data, &nct6775_pwm_template_group,
4363 data->pwm_num);
4367 err = nct6775_add_template_attr_group(dev, data, &nct6775_in_template_group,
4368 fls(data->have_in));
4372 err = nct6775_add_template_attr_group(dev, data, &nct6775_fan_template_group,
4373 fls(data->has_fan));
4377 err = nct6775_add_template_attr_group(dev, data, &nct6775_temp_template_group,
4378 fls(data->have_temp));
4382 if (data->have_tsi_temp) {
4385 tsi_temp_tg.base = fls(data->have_temp) + 1;
4386 err = nct6775_add_template_attr_group(dev, data, &tsi_temp_tg,
4387 fls(data->have_tsi_temp));
4392 hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name,
4393 data, data->groups);