Lines Matching refs:data
65 /* used to set data->name = nct6775_device_names[data->sio_kind] */
210 /* Common and NCT6775 specific data */
340 #define NCT6775_AUTO_TEMP(data, nr, p) ((data)->REG_AUTO_TEMP[nr] + (p))
341 #define NCT6775_AUTO_PWM(data, nr, p) ((data)->REG_AUTO_PWM[nr] + (p))
394 /* NCT6776 specific data */
477 /* NCT6779 specific data */
578 /* NCT6791 specific data */
601 /* NCT6792/NCT6793 specific data */
798 /* NCT6102D/NCT6106D specific data */
901 /* NCT6112D/NCT6114D/NCT6116D specific data */
1356 static bool is_word_sized(struct nct6775_data *data, u16 reg)
1358 switch (data->kind) {
1416 static inline void nct6775_set_bank(struct nct6775_data *data, u16 reg)
1420 if (data->bank != bank) {
1421 outb_p(NCT6775_REG_BANK, data->addr + ADDR_REG_OFFSET);
1422 outb_p(bank, data->addr + DATA_REG_OFFSET);
1423 data->bank = bank;
1427 static u16 nct6775_read_value(struct nct6775_data *data, u16 reg)
1429 int res, word_sized = is_word_sized(data, reg);
1431 nct6775_set_bank(data, reg);
1432 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
1433 res = inb_p(data->addr + DATA_REG_OFFSET);
1436 data->addr + ADDR_REG_OFFSET);
1437 res = (res << 8) + inb_p(data->addr + DATA_REG_OFFSET);
1442 static int nct6775_write_value(struct nct6775_data *data, u16 reg, u16 value)
1444 int word_sized = is_word_sized(data, reg);
1446 nct6775_set_bank(data, reg);
1447 outb_p(reg & 0xff, data->addr + ADDR_REG_OFFSET);
1449 outb_p(value >> 8, data->addr + DATA_REG_OFFSET);
1451 data->addr + ADDR_REG_OFFSET);
1453 outb_p(value & 0xff, data->addr + DATA_REG_OFFSET);
1458 static u16 nct6775_read_temp(struct nct6775_data *data, u16 reg)
1462 res = nct6775_read_value(data, reg);
1463 if (!is_word_sized(data, reg))
1469 static int nct6775_write_temp(struct nct6775_data *data, u16 reg, u16 value)
1471 if (!is_word_sized(data, reg))
1473 return nct6775_write_value(data, reg, value);
1476 /* This function assumes that the caller holds data->update_lock */
1477 static void nct6775_write_fan_div(struct nct6775_data *data, int nr)
1483 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x70)
1484 | (data->fan_div[0] & 0x7);
1485 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
1488 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV1) & 0x7)
1489 | ((data->fan_div[1] << 4) & 0x70);
1490 nct6775_write_value(data, NCT6775_REG_FANDIV1, reg);
1493 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x70)
1494 | (data->fan_div[2] & 0x7);
1495 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
1498 reg = (nct6775_read_value(data, NCT6775_REG_FANDIV2) & 0x7)
1499 | ((data->fan_div[3] << 4) & 0x70);
1500 nct6775_write_value(data, NCT6775_REG_FANDIV2, reg);
1505 static void nct6775_write_fan_div_common(struct nct6775_data *data, int nr)
1507 if (data->kind == nct6775)
1508 nct6775_write_fan_div(data, nr);
1511 static void nct6775_update_fan_div(struct nct6775_data *data)
1515 i = nct6775_read_value(data, NCT6775_REG_FANDIV1);
1516 data->fan_div[0] = i & 0x7;
1517 data->fan_div[1] = (i & 0x70) >> 4;
1518 i = nct6775_read_value(data, NCT6775_REG_FANDIV2);
1519 data->fan_div[2] = i & 0x7;
1520 if (data->has_fan & BIT(3))
1521 data->fan_div[3] = (i & 0x70) >> 4;
1524 static void nct6775_update_fan_div_common(struct nct6775_data *data)
1526 if (data->kind == nct6775)
1527 nct6775_update_fan_div(data);
1530 static void nct6775_init_fan_div(struct nct6775_data *data)
1534 nct6775_update_fan_div_common(data);
1541 for (i = 0; i < ARRAY_SIZE(data->fan_div); i++) {
1542 if (!(data->has_fan & BIT(i)))
1544 if (data->fan_div[i] == 0) {
1545 data->fan_div[i] = 7;
1546 nct6775_write_fan_div_common(data, i);
1552 struct nct6775_data *data)
1557 if (data->has_fan_div)
1558 nct6775_init_fan_div(data);
1564 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1565 if (data->has_fan_min & BIT(i)) {
1566 reg = nct6775_read_value(data, data->REG_FAN_MIN[i]);
1568 nct6775_write_value(data, data->REG_FAN_MIN[i],
1569 data->has_fan_div ? 0xff
1576 struct nct6775_data *data, int nr, u16 reg)
1578 u8 fan_div = data->fan_div[nr];
1581 if (!data->has_fan_div)
1594 if (fan_div != data->fan_div[nr]) {
1596 nr + 1, div_from_reg(data->fan_div[nr]),
1600 if (data->has_fan_min & BIT(nr)) {
1601 fan_min = data->fan_min[nr];
1602 if (fan_div > data->fan_div[nr]) {
1612 if (fan_min != data->fan_min[nr]) {
1613 data->fan_min[nr] = fan_min;
1614 nct6775_write_value(data, data->REG_FAN_MIN[nr],
1618 data->fan_div[nr] = fan_div;
1619 nct6775_write_fan_div_common(data, nr);
1625 struct nct6775_data *data = dev_get_drvdata(dev);
1630 for (i = 0; i < data->pwm_num; i++) {
1631 if (!(data->has_pwm & BIT(i)))
1634 duty_is_dc = data->REG_PWM_MODE[i] &&
1635 (nct6775_read_value(data, data->REG_PWM_MODE[i])
1636 & data->PWM_MODE_MASK[i]);
1637 data->pwm_mode[i] = !duty_is_dc;
1639 fanmodecfg = nct6775_read_value(data, data->REG_FAN_MODE[i]);
1640 for (j = 0; j < ARRAY_SIZE(data->REG_PWM); j++) {
1641 if (data->REG_PWM[j] && data->REG_PWM[j][i]) {
1642 data->pwm[j][i]
1643 = nct6775_read_value(data,
1644 data->REG_PWM[j][i]);
1648 data->pwm_enable[i] = reg_to_pwm_enable(data->pwm[0][i],
1651 if (!data->temp_tolerance[0][i] ||
1652 data->pwm_enable[i] != speed_cruise)
1653 data->temp_tolerance[0][i] = fanmodecfg & 0x0f;
1654 if (!data->target_speed_tolerance[i] ||
1655 data->pwm_enable[i] == speed_cruise) {
1658 if (data->REG_TOLERANCE_H) {
1659 t |= (nct6775_read_value(data,
1660 data->REG_TOLERANCE_H[i]) & 0x70) >> 1;
1662 data->target_speed_tolerance[i] = t;
1665 data->temp_tolerance[1][i] =
1666 nct6775_read_value(data,
1667 data->REG_CRITICAL_TEMP_TOLERANCE[i]);
1669 reg = nct6775_read_value(data, data->REG_TEMP_SEL[i]);
1670 data->pwm_temp_sel[i] = reg & 0x1f;
1673 data->pwm[2][i] = 0;
1675 if (!data->REG_WEIGHT_TEMP_SEL[i])
1678 reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[i]);
1679 data->pwm_weight_temp_sel[i] = reg & 0x1f;
1682 data->pwm_weight_temp_sel[i] = 0;
1684 /* Weight temp data */
1685 for (j = 0; j < ARRAY_SIZE(data->weight_temp); j++) {
1686 data->weight_temp[j][i]
1687 = nct6775_read_value(data,
1688 data->REG_WEIGHT_TEMP[j][i]);
1695 struct nct6775_data *data = dev_get_drvdata(dev);
1700 for (i = 0; i < data->pwm_num; i++) {
1701 if (!(data->has_pwm & BIT(i)))
1704 for (j = 0; j < ARRAY_SIZE(data->fan_time); j++) {
1705 data->fan_time[j][i] =
1706 nct6775_read_value(data, data->REG_FAN_TIME[j][i]);
1709 reg_t = nct6775_read_value(data, data->REG_TARGET[i]);
1711 if (!data->target_temp[i] ||
1712 data->pwm_enable[i] == thermal_cruise)
1713 data->target_temp[i] = reg_t & data->target_temp_mask;
1714 if (!data->target_speed[i] ||
1715 data->pwm_enable[i] == speed_cruise) {
1716 if (data->REG_TOLERANCE_H) {
1717 reg_t |= (nct6775_read_value(data,
1718 data->REG_TOLERANCE_H[i]) & 0x0f) << 8;
1720 data->target_speed[i] = reg_t;
1723 for (j = 0; j < data->auto_pwm_num; j++) {
1724 data->auto_pwm[i][j] =
1725 nct6775_read_value(data,
1726 NCT6775_AUTO_PWM(data, i, j));
1727 data->auto_temp[i][j] =
1728 nct6775_read_value(data,
1729 NCT6775_AUTO_TEMP(data, i, j));
1732 /* critical auto_pwm temperature data */
1733 data->auto_temp[i][data->auto_pwm_num] =
1734 nct6775_read_value(data, data->REG_CRITICAL_TEMP[i]);
1736 switch (data->kind) {
1738 reg = nct6775_read_value(data,
1740 data->auto_pwm[i][data->auto_pwm_num] =
1744 data->auto_pwm[i][data->auto_pwm_num] = 0xff;
1756 reg = nct6775_read_value(data,
1757 data->REG_CRITICAL_PWM_ENABLE[i]);
1758 if (reg & data->CRITICAL_PWM_ENABLE_MASK)
1759 reg = nct6775_read_value(data,
1760 data->REG_CRITICAL_PWM[i]);
1763 data->auto_pwm[i][data->auto_pwm_num] = reg;
1771 struct nct6775_data *data = dev_get_drvdata(dev);
1774 mutex_lock(&data->update_lock);
1776 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
1777 || !data->valid) {
1779 nct6775_update_fan_div_common(data);
1782 for (i = 0; i < data->in_num; i++) {
1783 if (!(data->have_in & BIT(i)))
1786 data->in[i][0] = nct6775_read_value(data,
1787 data->REG_VIN[i]);
1788 data->in[i][1] = nct6775_read_value(data,
1789 data->REG_IN_MINMAX[0][i]);
1790 data->in[i][2] = nct6775_read_value(data,
1791 data->REG_IN_MINMAX[1][i]);
1795 for (i = 0; i < ARRAY_SIZE(data->rpm); i++) {
1798 if (!(data->has_fan & BIT(i)))
1801 reg = nct6775_read_value(data, data->REG_FAN[i]);
1802 data->rpm[i] = data->fan_from_reg(reg,
1803 data->fan_div[i]);
1805 if (data->has_fan_min & BIT(i))
1806 data->fan_min[i] = nct6775_read_value(data,
1807 data->REG_FAN_MIN[i]);
1809 if (data->REG_FAN_PULSES[i]) {
1810 data->fan_pulses[i] =
1811 (nct6775_read_value(data,
1812 data->REG_FAN_PULSES[i])
1813 >> data->FAN_PULSE_SHIFT[i]) & 0x03;
1816 nct6775_select_fan_div(dev, data, i, reg);
1824 if (!(data->have_temp & BIT(i)))
1826 for (j = 0; j < ARRAY_SIZE(data->reg_temp); j++) {
1827 if (data->reg_temp[j][i])
1828 data->temp[j][i]
1829 = nct6775_read_temp(data,
1830 data->reg_temp[j][i]);
1833 !(data->have_temp_fixed & BIT(i)))
1835 data->temp_offset[i]
1836 = nct6775_read_value(data, data->REG_TEMP_OFFSET[i]);
1839 data->alarms = 0;
1843 if (!data->REG_ALARM[i])
1845 alarm = nct6775_read_value(data, data->REG_ALARM[i]);
1846 data->alarms |= ((u64)alarm) << (i << 3);
1849 data->beeps = 0;
1853 if (!data->REG_BEEP[i])
1855 beep = nct6775_read_value(data, data->REG_BEEP[i]);
1856 data->beeps |= ((u64)beep) << (i << 3);
1859 data->last_updated = jiffies;
1860 data->valid = true;
1863 mutex_unlock(&data->update_lock);
1864 return data;
1873 struct nct6775_data *data = nct6775_update_device(dev);
1878 return sprintf(buf, "%ld\n", in_from_reg(data->in[nr][index], nr));
1885 struct nct6775_data *data = dev_get_drvdata(dev);
1895 mutex_lock(&data->update_lock);
1896 data->in[nr][index] = in_to_reg(val, nr);
1897 nct6775_write_value(data, data->REG_IN_MINMAX[index - 1][nr],
1898 data->in[nr][index]);
1899 mutex_unlock(&data->update_lock);
1906 struct nct6775_data *data = nct6775_update_device(dev);
1908 int nr = data->ALARM_BITS[sattr->index];
1911 (unsigned int)((data->alarms >> nr) & 0x01));
1914 static int find_temp_source(struct nct6775_data *data, int index, int count)
1916 int source = data->temp_src[index];
1922 src = nct6775_read_value(data,
1923 data->REG_TEMP_SOURCE[nr]) & 0x1f;
1934 struct nct6775_data *data = nct6775_update_device(dev);
1942 nr = find_temp_source(data, sattr->index, data->num_temp_alarms);
1944 int bit = data->ALARM_BITS[nr + TEMP_ALARM_BASE];
1946 alarm = (data->alarms >> bit) & 0x01;
1955 struct nct6775_data *data = nct6775_update_device(dev);
1956 int nr = data->BEEP_BITS[sattr->index];
1959 (unsigned int)((data->beeps >> nr) & 0x01));
1967 struct nct6775_data *data = dev_get_drvdata(dev);
1968 int nr = data->BEEP_BITS[sattr->index];
1979 mutex_lock(&data->update_lock);
1981 data->beeps |= (1ULL << nr);
1983 data->beeps &= ~(1ULL << nr);
1984 nct6775_write_value(data, data->REG_BEEP[regindex],
1985 (data->beeps >> (regindex << 3)) & 0xff);
1986 mutex_unlock(&data->update_lock);
1994 struct nct6775_data *data = nct6775_update_device(dev);
2003 nr = find_temp_source(data, sattr->index, data->num_temp_beeps);
2005 int bit = data->BEEP_BITS[nr + TEMP_ALARM_BASE];
2007 beep = (data->beeps >> bit) & 0x01;
2017 struct nct6775_data *data = dev_get_drvdata(dev);
2028 nr = find_temp_source(data, sattr->index, data->num_temp_beeps);
2032 bit = data->BEEP_BITS[nr + TEMP_ALARM_BASE];
2035 mutex_lock(&data->update_lock);
2037 data->beeps |= (1ULL << bit);
2039 data->beeps &= ~(1ULL << bit);
2040 nct6775_write_value(data, data->REG_BEEP[regindex],
2041 (data->beeps >> (regindex << 3)) & 0xff);
2042 mutex_unlock(&data->update_lock);
2051 struct nct6775_data *data = dev_get_drvdata(dev);
2054 if (!(data->have_in & BIT(in)))
2091 struct nct6775_data *data = nct6775_update_device(dev);
2095 return sprintf(buf, "%d\n", data->rpm[nr]);
2101 struct nct6775_data *data = nct6775_update_device(dev);
2106 data->fan_from_reg_min(data->fan_min[nr],
2107 data->fan_div[nr]));
2113 struct nct6775_data *data = nct6775_update_device(dev);
2117 return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
2124 struct nct6775_data *data = dev_get_drvdata(dev);
2136 mutex_lock(&data->update_lock);
2137 if (!data->has_fan_div) {
2147 data->fan_min[nr] = val;
2152 data->fan_min[nr] = 255;
2153 new_div = data->fan_div[nr]; /* No change */
2163 data->fan_min[nr] = 254;
2167 nr + 1, val, data->fan_from_reg_min(254, 7));
2173 data->fan_min[nr] = 1;
2177 nr + 1, val, data->fan_from_reg_min(1, 0));
2189 data->fan_min[nr] = reg;
2197 if (new_div != data->fan_div[nr]) {
2199 nr + 1, div_from_reg(data->fan_div[nr]),
2201 data->fan_div[nr] = new_div;
2202 nct6775_write_fan_div_common(data, nr);
2204 data->last_updated = jiffies;
2208 nct6775_write_value(data, data->REG_FAN_MIN[nr], data->fan_min[nr]);
2209 mutex_unlock(&data->update_lock);
2217 struct nct6775_data *data = nct6775_update_device(dev);
2219 int p = data->fan_pulses[sattr->index];
2228 struct nct6775_data *data = dev_get_drvdata(dev);
2242 mutex_lock(&data->update_lock);
2243 data->fan_pulses[nr] = val & 3;
2244 reg = nct6775_read_value(data, data->REG_FAN_PULSES[nr]);
2245 reg &= ~(0x03 << data->FAN_PULSE_SHIFT[nr]);
2246 reg |= (val & 3) << data->FAN_PULSE_SHIFT[nr];
2247 nct6775_write_value(data, data->REG_FAN_PULSES[nr], reg);
2248 mutex_unlock(&data->update_lock);
2257 struct nct6775_data *data = dev_get_drvdata(dev);
2261 if (!(data->has_fan & BIT(fan)))
2264 if (nr == 1 && data->ALARM_BITS[FAN_ALARM_BASE + fan] == -1)
2266 if (nr == 2 && data->BEEP_BITS[FAN_ALARM_BASE + fan] == -1)
2268 if (nr == 3 && !data->REG_FAN_PULSES[fan])
2270 if (nr == 4 && !(data->has_fan_min & BIT(fan)))
2272 if (nr == 5 && data->kind != nct6775)
2313 struct nct6775_data *data = nct6775_update_device(dev);
2317 return sprintf(buf, "%s\n", data->temp_label[data->temp_src[nr]]);
2323 struct nct6775_data *data = nct6775_update_device(dev);
2328 return sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(data->temp[index][nr]));
2335 struct nct6775_data *data = dev_get_drvdata(dev);
2346 mutex_lock(&data->update_lock);
2347 data->temp[index][nr] = LM75_TEMP_TO_REG(val);
2348 nct6775_write_temp(data, data->reg_temp[index][nr],
2349 data->temp[index][nr]);
2350 mutex_unlock(&data->update_lock);
2357 struct nct6775_data *data = nct6775_update_device(dev);
2360 return sprintf(buf, "%d\n", data->temp_offset[sattr->index] * 1000);
2367 struct nct6775_data *data = dev_get_drvdata(dev);
2379 mutex_lock(&data->update_lock);
2380 data->temp_offset[nr] = val;
2381 nct6775_write_value(data, data->REG_TEMP_OFFSET[nr], val);
2382 mutex_unlock(&data->update_lock);
2390 struct nct6775_data *data = nct6775_update_device(dev);
2394 return sprintf(buf, "%d\n", (int)data->temp_type[nr]);
2401 struct nct6775_data *data = nct6775_update_device(dev);
2415 mutex_lock(&data->update_lock);
2417 data->temp_type[nr] = val;
2419 dbit = data->DIODE_MASK << nr;
2420 vbat = nct6775_read_value(data, data->REG_VBAT) & ~vbit;
2421 diode = nct6775_read_value(data, data->REG_DIODE) & ~dbit;
2433 nct6775_write_value(data, data->REG_VBAT, vbat);
2434 nct6775_write_value(data, data->REG_DIODE, diode);
2436 mutex_unlock(&data->update_lock);
2444 struct nct6775_data *data = dev_get_drvdata(dev);
2448 if (!(data->have_temp & BIT(temp)))
2451 if (nr == 1 && !data->temp_label)
2454 if (nr == 2 && find_temp_source(data, temp, data->num_temp_alarms) < 0)
2457 if (nr == 3 && find_temp_source(data, temp, data->num_temp_beeps) < 0)
2460 if (nr == 4 && !data->reg_temp[1][temp]) /* max */
2463 if (nr == 5 && !data->reg_temp[2][temp]) /* max_hyst */
2466 if (nr == 6 && !data->reg_temp[3][temp]) /* crit */
2469 if (nr == 7 && !data->reg_temp[4][temp]) /* lcrit */
2473 if (nr > 7 && !(data->have_temp_fixed & BIT(temp)))
2525 struct nct6775_data *data = nct6775_update_device(dev);
2528 return sprintf(buf, "%d\n", data->pwm_mode[sattr->index]);
2535 struct nct6775_data *data = dev_get_drvdata(dev);
2550 if (data->REG_PWM_MODE[nr] == 0) {
2556 mutex_lock(&data->update_lock);
2557 data->pwm_mode[nr] = val;
2558 reg = nct6775_read_value(data, data->REG_PWM_MODE[nr]);
2559 reg &= ~data->PWM_MODE_MASK[nr];
2561 reg |= data->PWM_MODE_MASK[nr];
2562 nct6775_write_value(data, data->REG_PWM_MODE[nr], reg);
2563 mutex_unlock(&data->update_lock);
2570 struct nct6775_data *data = nct6775_update_device(dev);
2580 if (index == 0 && data->pwm_enable[nr] > manual)
2581 pwm = nct6775_read_value(data, data->REG_PWM_READ[nr]);
2583 pwm = data->pwm[index][nr];
2592 struct nct6775_data *data = dev_get_drvdata(dev);
2597 int minval[7] = { 0, 1, 1, data->pwm[2][nr], 0, 0, 0 };
2599 = { 255, 255, data->pwm[3][nr] ? : 255, 255, 255, 255, 255 };
2608 mutex_lock(&data->update_lock);
2609 data->pwm[index][nr] = val;
2610 nct6775_write_value(data, data->REG_PWM[index][nr], val);
2612 reg = nct6775_read_value(data, data->REG_TEMP_SEL[nr]);
2616 nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg);
2618 mutex_unlock(&data->update_lock);
2623 static int check_trip_points(struct nct6775_data *data, int nr)
2627 for (i = 0; i < data->auto_pwm_num - 1; i++) {
2628 if (data->auto_temp[nr][i] > data->auto_temp[nr][i + 1])
2631 for (i = 0; i < data->auto_pwm_num - 1; i++) {
2632 if (data->auto_pwm[nr][i] > data->auto_pwm[nr][i + 1])
2636 if (data->auto_pwm[nr][data->auto_pwm_num]) {
2637 if (data->auto_temp[nr][data->auto_pwm_num - 1] >
2638 data->auto_temp[nr][data->auto_pwm_num] ||
2639 data->auto_pwm[nr][data->auto_pwm_num - 1] >
2640 data->auto_pwm[nr][data->auto_pwm_num])
2646 static void pwm_update_registers(struct nct6775_data *data, int nr)
2650 switch (data->pwm_enable[nr]) {
2655 reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
2656 reg = (reg & ~data->tolerance_mask) |
2657 (data->target_speed_tolerance[nr] & data->tolerance_mask);
2658 nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2659 nct6775_write_value(data, data->REG_TARGET[nr],
2660 data->target_speed[nr] & 0xff);
2661 if (data->REG_TOLERANCE_H) {
2662 reg = (data->target_speed[nr] >> 8) & 0x0f;
2663 reg |= (data->target_speed_tolerance[nr] & 0x38) << 1;
2664 nct6775_write_value(data,
2665 data->REG_TOLERANCE_H[nr],
2670 nct6775_write_value(data, data->REG_TARGET[nr],
2671 data->target_temp[nr]);
2674 reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
2675 reg = (reg & ~data->tolerance_mask) |
2676 data->temp_tolerance[0][nr];
2677 nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2685 struct nct6775_data *data = nct6775_update_device(dev);
2688 return sprintf(buf, "%d\n", data->pwm_enable[sattr->index]);
2695 struct nct6775_data *data = dev_get_drvdata(dev);
2709 if (val == sf3 && data->kind != nct6775)
2712 if (val == sf4 && check_trip_points(data, nr)) {
2718 mutex_lock(&data->update_lock);
2719 data->pwm_enable[nr] = val;
2724 data->pwm[0][nr] = 255;
2725 nct6775_write_value(data, data->REG_PWM[0][nr], 255);
2727 pwm_update_registers(data, nr);
2728 reg = nct6775_read_value(data, data->REG_FAN_MODE[nr]);
2731 nct6775_write_value(data, data->REG_FAN_MODE[nr], reg);
2732 mutex_unlock(&data->update_lock);
2737 show_pwm_temp_sel_common(struct nct6775_data *data, char *buf, int src)
2742 if (!(data->have_temp & BIT(i)))
2744 if (src == data->temp_src[i]) {
2756 struct nct6775_data *data = nct6775_update_device(dev);
2760 return show_pwm_temp_sel_common(data, buf, data->pwm_temp_sel[index]);
2767 struct nct6775_data *data = nct6775_update_device(dev);
2778 if (!(data->have_temp & BIT(val - 1)) || !data->temp_src[val - 1])
2781 mutex_lock(&data->update_lock);
2782 src = data->temp_src[val - 1];
2783 data->pwm_temp_sel[nr] = src;
2784 reg = nct6775_read_value(data, data->REG_TEMP_SEL[nr]);
2787 nct6775_write_value(data, data->REG_TEMP_SEL[nr], reg);
2788 mutex_unlock(&data->update_lock);
2797 struct nct6775_data *data = nct6775_update_device(dev);
2801 return show_pwm_temp_sel_common(data, buf,
2802 data->pwm_weight_temp_sel[index]);
2809 struct nct6775_data *data = nct6775_update_device(dev);
2821 if (val && (!(data->have_temp & BIT(val - 1)) ||
2822 !data->temp_src[val - 1]))
2825 mutex_lock(&data->update_lock);
2827 src = data->temp_src[val - 1];
2828 data->pwm_weight_temp_sel[nr] = src;
2829 reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]);
2832 nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
2834 data->pwm_weight_temp_sel[nr] = 0;
2835 reg = nct6775_read_value(data, data->REG_WEIGHT_TEMP_SEL[nr]);
2837 nct6775_write_value(data, data->REG_WEIGHT_TEMP_SEL[nr], reg);
2839 mutex_unlock(&data->update_lock);
2847 struct nct6775_data *data = nct6775_update_device(dev);
2850 return sprintf(buf, "%d\n", data->target_temp[sattr->index] * 1000);
2857 struct nct6775_data *data = dev_get_drvdata(dev);
2868 data->target_temp_mask);
2870 mutex_lock(&data->update_lock);
2871 data->target_temp[nr] = val;
2872 pwm_update_registers(data, nr);
2873 mutex_unlock(&data->update_lock);
2880 struct nct6775_data *data = nct6775_update_device(dev);
2885 fan_from_reg16(data->target_speed[nr],
2886 data->fan_div[nr]));
2893 struct nct6775_data *data = dev_get_drvdata(dev);
2905 speed = fan_to_reg(val, data->fan_div[nr]);
2907 mutex_lock(&data->update_lock);
2908 data->target_speed[nr] = speed;
2909 pwm_update_registers(data, nr);
2910 mutex_unlock(&data->update_lock);
2918 struct nct6775_data *data = nct6775_update_device(dev);
2923 return sprintf(buf, "%d\n", data->temp_tolerance[index][nr] * 1000);
2930 struct nct6775_data *data = dev_get_drvdata(dev);
2942 val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, data->tolerance_mask);
2944 mutex_lock(&data->update_lock);
2945 data->temp_tolerance[index][nr] = val;
2947 pwm_update_registers(data, nr);
2949 nct6775_write_value(data,
2950 data->REG_CRITICAL_TEMP_TOLERANCE[nr],
2952 mutex_unlock(&data->update_lock);
2967 struct nct6775_data *data = nct6775_update_device(dev);
2970 int target = data->target_speed[nr];
2974 int low = target - data->target_speed_tolerance[nr];
2975 int high = target + data->target_speed_tolerance[nr];
2984 tolerance = (fan_from_reg16(low, data->fan_div[nr])
2985 - fan_from_reg16(high, data->fan_div[nr])) / 2;
2995 struct nct6775_data *data = dev_get_drvdata(dev);
3006 high = fan_from_reg16(data->target_speed[nr],
3007 data->fan_div[nr]) + val;
3008 low = fan_from_reg16(data->target_speed[nr],
3009 data->fan_div[nr]) - val;
3015 val = (fan_to_reg(low, data->fan_div[nr]) -
3016 fan_to_reg(high, data->fan_div[nr])) / 2;
3019 val = clamp_val(val, 0, data->speed_tolerance_limit);
3021 mutex_lock(&data->update_lock);
3022 data->target_speed_tolerance[nr] = val;
3023 pwm_update_registers(data, nr);
3024 mutex_unlock(&data->update_lock);
3047 struct nct6775_data *data = nct6775_update_device(dev);
3052 return sprintf(buf, "%d\n", data->weight_temp[index][nr] * 1000);
3059 struct nct6775_data *data = dev_get_drvdata(dev);
3072 mutex_lock(&data->update_lock);
3073 data->weight_temp[index][nr] = val;
3074 nct6775_write_value(data, data->REG_WEIGHT_TEMP[index][nr], val);
3075 mutex_unlock(&data->update_lock);
3095 struct nct6775_data *data = nct6775_update_device(dev);
3101 step_time_from_reg(data->fan_time[index][nr],
3102 data->pwm_mode[nr]));
3109 struct nct6775_data *data = dev_get_drvdata(dev);
3120 val = step_time_to_reg(val, data->pwm_mode[nr]);
3121 mutex_lock(&data->update_lock);
3122 data->fan_time[index][nr] = val;
3123 nct6775_write_value(data, data->REG_FAN_TIME[index][nr], val);
3124 mutex_unlock(&data->update_lock);
3131 struct nct6775_data *data = nct6775_update_device(dev);
3134 return sprintf(buf, "%d\n", data->auto_pwm[sattr->nr][sattr->index]);
3141 struct nct6775_data *data = dev_get_drvdata(dev);
3155 if (point == data->auto_pwm_num) {
3156 if (data->kind != nct6775 && !val)
3158 if (data->kind != nct6779 && val)
3162 mutex_lock(&data->update_lock);
3163 data->auto_pwm[nr][point] = val;
3164 if (point < data->auto_pwm_num) {
3165 nct6775_write_value(data,
3166 NCT6775_AUTO_PWM(data, nr, point),
3167 data->auto_pwm[nr][point]);
3169 switch (data->kind) {
3172 reg = nct6775_read_value(data,
3178 nct6775_write_value(data, NCT6775_REG_CRITICAL_ENAB[nr],
3193 nct6775_write_value(data, data->REG_CRITICAL_PWM[nr],
3195 reg = nct6775_read_value(data,
3196 data->REG_CRITICAL_PWM_ENABLE[nr]);
3198 reg &= ~data->CRITICAL_PWM_ENABLE_MASK;
3200 reg |= data->CRITICAL_PWM_ENABLE_MASK;
3201 nct6775_write_value(data,
3202 data->REG_CRITICAL_PWM_ENABLE[nr],
3207 mutex_unlock(&data->update_lock);
3214 struct nct6775_data *data = nct6775_update_device(dev);
3223 return sprintf(buf, "%d\n", data->auto_temp[nr][point] * 1000);
3230 struct nct6775_data *data = dev_get_drvdata(dev);
3243 mutex_lock(&data->update_lock);
3244 data->auto_temp[nr][point] = DIV_ROUND_CLOSEST(val, 1000);
3245 if (point < data->auto_pwm_num) {
3246 nct6775_write_value(data,
3247 NCT6775_AUTO_TEMP(data, nr, point),
3248 data->auto_temp[nr][point]);
3250 nct6775_write_value(data, data->REG_CRITICAL_TEMP[nr],
3251 data->auto_temp[nr][point]);
3253 mutex_unlock(&data->update_lock);
3261 struct nct6775_data *data = dev_get_drvdata(dev);
3265 if (!(data->has_pwm & BIT(pwm)))
3269 if (!data->REG_WEIGHT_TEMP_SEL[pwm])
3271 if (nr == 19 && data->REG_PWM[3] == NULL) /* pwm_max */
3273 if (nr == 20 && data->REG_PWM[4] == NULL) /* pwm_step */
3275 if (nr == 21 && data->REG_PWM[6] == NULL) /* weight_duty_base */
3281 if (api > data->auto_pwm_num)
3399 struct nct6775_data *data = dev_get_drvdata(dev);
3401 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
3412 struct nct6775_data *data = dev_get_drvdata(dev);
3421 mutex_lock(&data->update_lock);
3428 ret = superio_enter(data->sioreg);
3434 superio_select(data->sioreg, NCT6775_LD_ACPI);
3435 reg = superio_inb(data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr]);
3437 superio_outb(data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg);
3439 superio_outb(data->sioreg, NCT6775_REG_CR_CASEOPEN_CLR[nr], reg);
3440 superio_exit(data->sioreg);
3442 data->valid = false; /* Force cache refresh */
3444 mutex_unlock(&data->update_lock);
3463 struct nct6775_data *data = dev_get_drvdata(dev);
3465 if (index == 0 && !data->have_vid)
3469 if (data->ALARM_BITS[INTRUSION_ALARM_BASE + index - 1] < 0)
3474 if (data->BEEP_BITS[INTRUSION_ALARM_BASE + index - 3] < 0)
3502 static inline void nct6775_init_device(struct nct6775_data *data)
3508 if (data->REG_CONFIG) {
3509 tmp = nct6775_read_value(data, data->REG_CONFIG);
3511 nct6775_write_value(data, data->REG_CONFIG, tmp | 0x01);
3516 if (!(data->have_temp & BIT(i)))
3518 if (!data->reg_temp_config[i])
3520 tmp = nct6775_read_value(data, data->reg_temp_config[i]);
3522 nct6775_write_value(data, data->reg_temp_config[i],
3527 tmp = nct6775_read_value(data, data->REG_VBAT);
3529 nct6775_write_value(data, data->REG_VBAT, tmp | 0x01);
3531 diode = nct6775_read_value(data, data->REG_DIODE);
3533 for (i = 0; i < data->temp_fixed_num; i++) {
3534 if (!(data->have_temp_fixed & BIT(i)))
3536 if ((tmp & (data->DIODE_MASK << i))) /* diode */
3537 data->temp_type[i]
3538 = 3 - ((diode >> i) & data->DIODE_MASK);
3540 data->temp_type[i] = 4;
3545 nct6775_check_fan_inputs(struct nct6775_data *data)
3551 int sioreg = data->sioreg;
3555 data->sio_reg_enable = superio_inb(sioreg, SIO_REG_ENABLE);
3558 if (data->kind == nct6775) {
3566 } else if (data->kind == nct6776) {
3581 if ((data->sio_reg_enable & 0xe0) != 0xe0) {
3582 data->sio_reg_enable |= 0xe0;
3584 data->sio_reg_enable);
3589 if (data->sio_reg_enable & 0x80)
3594 if (data->sio_reg_enable & 0x40)
3599 if (data->sio_reg_enable & 0x20)
3606 } else if (data->kind == nct6106) {
3611 } else if (data->kind == nct6116) {
3660 switch (data->kind) {
3758 data->has_fan = 0x03 | (fan3pin << 2) | (fan4pin << 3) |
3760 data->has_fan_min = 0x03 | (fan3pin << 2) | (fan4min << 3) |
3762 data->has_pwm = 0x03 | (pwm3pin << 2) | (pwm4pin << 3) |
3766 static void add_temp_sensors(struct nct6775_data *data, const u16 *regp,
3772 for (i = 0; i < data->pwm_num && *available; i++) {
3777 src = nct6775_read_value(data, regp[i]);
3781 if (!(data->temp_mask & BIT(src)))
3785 nct6775_write_value(data, data->REG_TEMP_SOURCE[index], src);
3795 struct nct6775_data *data;
3813 data = devm_kzalloc(&pdev->dev, sizeof(struct nct6775_data),
3815 if (!data)
3818 data->kind = sio_data->kind;
3819 data->sioreg = sio_data->sioreg;
3820 data->addr = res->start;
3821 mutex_init(&data->update_lock);
3822 data->name = nct6775_device_names[data->kind];
3823 data->bank = 0xff; /* Force initial bank selection */
3824 platform_set_drvdata(pdev, data);
3826 switch (data->kind) {
3828 data->in_num = 9;
3829 data->pwm_num = 3;
3830 data->auto_pwm_num = 4;
3831 data->temp_fixed_num = 3;
3832 data->num_temp_alarms = 6;
3833 data->num_temp_beeps = 6;
3835 data->fan_from_reg = fan_from_reg13;
3836 data->fan_from_reg_min = fan_from_reg13;
3838 data->temp_label = nct6776_temp_label;
3839 data->temp_mask = NCT6776_TEMP_MASK;
3840 data->virt_temp_mask = NCT6776_VIRT_TEMP_MASK;
3842 data->REG_VBAT = NCT6106_REG_VBAT;
3843 data->REG_DIODE = NCT6106_REG_DIODE;
3844 data->DIODE_MASK = NCT6106_DIODE_MASK;
3845 data->REG_VIN = NCT6106_REG_IN;
3846 data->REG_IN_MINMAX[0] = NCT6106_REG_IN_MIN;
3847 data->REG_IN_MINMAX[1] = NCT6106_REG_IN_MAX;
3848 data->REG_TARGET = NCT6106_REG_TARGET;
3849 data->REG_FAN = NCT6106_REG_FAN;
3850 data->REG_FAN_MODE = NCT6106_REG_FAN_MODE;
3851 data->REG_FAN_MIN = NCT6106_REG_FAN_MIN;
3852 data->REG_FAN_PULSES = NCT6106_REG_FAN_PULSES;
3853 data->FAN_PULSE_SHIFT = NCT6106_FAN_PULSE_SHIFT;
3854 data->REG_FAN_TIME[0] = NCT6106_REG_FAN_STOP_TIME;
3855 data->REG_FAN_TIME[1] = NCT6106_REG_FAN_STEP_UP_TIME;
3856 data->REG_FAN_TIME[2] = NCT6106_REG_FAN_STEP_DOWN_TIME;
3857 data->REG_TOLERANCE_H = NCT6106_REG_TOLERANCE_H;
3858 data->REG_PWM[0] = NCT6116_REG_PWM;
3859 data->REG_PWM[1] = NCT6106_REG_FAN_START_OUTPUT;
3860 data->REG_PWM[2] = NCT6106_REG_FAN_STOP_OUTPUT;
3861 data->REG_PWM[5] = NCT6106_REG_WEIGHT_DUTY_STEP;
3862 data->REG_PWM[6] = NCT6106_REG_WEIGHT_DUTY_BASE;
3863 data->REG_PWM_READ = NCT6106_REG_PWM_READ;
3864 data->REG_PWM_MODE = NCT6106_REG_PWM_MODE;
3865 data->PWM_MODE_MASK = NCT6106_PWM_MODE_MASK;
3866 data->REG_AUTO_TEMP = NCT6106_REG_AUTO_TEMP;
3867 data->REG_AUTO_PWM = NCT6106_REG_AUTO_PWM;
3868 data->REG_CRITICAL_TEMP = NCT6106_REG_CRITICAL_TEMP;
3869 data->REG_CRITICAL_TEMP_TOLERANCE
3871 data->REG_CRITICAL_PWM_ENABLE = NCT6106_REG_CRITICAL_PWM_ENABLE;
3872 data->CRITICAL_PWM_ENABLE_MASK
3874 data->REG_CRITICAL_PWM = NCT6106_REG_CRITICAL_PWM;
3875 data->REG_TEMP_OFFSET = NCT6106_REG_TEMP_OFFSET;
3876 data->REG_TEMP_SOURCE = NCT6106_REG_TEMP_SOURCE;
3877 data->REG_TEMP_SEL = NCT6116_REG_TEMP_SEL;
3878 data->REG_WEIGHT_TEMP_SEL = NCT6106_REG_WEIGHT_TEMP_SEL;
3879 data->REG_WEIGHT_TEMP[0] = NCT6106_REG_WEIGHT_TEMP_STEP;
3880 data->REG_WEIGHT_TEMP[1] = NCT6106_REG_WEIGHT_TEMP_STEP_TOL;
3881 data->REG_WEIGHT_TEMP[2] = NCT6106_REG_WEIGHT_TEMP_BASE;
3882 data->REG_ALARM = NCT6106_REG_ALARM;
3883 data->ALARM_BITS = NCT6106_ALARM_BITS;
3884 data->REG_BEEP = NCT6106_REG_BEEP;
3885 data->BEEP_BITS = NCT6106_BEEP_BITS;
3901 data->in_num = 9;
3902 data->pwm_num = 3;
3903 data->auto_pwm_num = 4;
3904 data->temp_fixed_num = 3;
3905 data->num_temp_alarms = 3;
3906 data->num_temp_beeps = 3;
3908 data->fan_from_reg = fan_from_reg13;
3909 data->fan_from_reg_min = fan_from_reg13;
3911 data->temp_label = nct6776_temp_label;
3912 data->temp_mask = NCT6776_TEMP_MASK;
3913 data->virt_temp_mask = NCT6776_VIRT_TEMP_MASK;
3915 data->REG_VBAT = NCT6106_REG_VBAT;
3916 data->REG_DIODE = NCT6106_REG_DIODE;
3917 data->DIODE_MASK = NCT6106_DIODE_MASK;
3918 data->REG_VIN = NCT6106_REG_IN;
3919 data->REG_IN_MINMAX[0] = NCT6106_REG_IN_MIN;
3920 data->REG_IN_MINMAX[1] = NCT6106_REG_IN_MAX;
3921 data->REG_TARGET = NCT6116_REG_TARGET;
3922 data->REG_FAN = NCT6116_REG_FAN;
3923 data->REG_FAN_MODE = NCT6116_REG_FAN_MODE;
3924 data->REG_FAN_MIN = NCT6116_REG_FAN_MIN;
3925 data->REG_FAN_PULSES = NCT6116_REG_FAN_PULSES;
3926 data->FAN_PULSE_SHIFT = NCT6116_FAN_PULSE_SHIFT;
3927 data->REG_FAN_TIME[0] = NCT6116_REG_FAN_STOP_TIME;
3928 data->REG_FAN_TIME[1] = NCT6116_REG_FAN_STEP_UP_TIME;
3929 data->REG_FAN_TIME[2] = NCT6116_REG_FAN_STEP_DOWN_TIME;
3930 data->REG_TOLERANCE_H = NCT6116_REG_TOLERANCE_H;
3931 data->REG_PWM[0] = NCT6116_REG_PWM;
3932 data->REG_PWM[1] = NCT6116_REG_FAN_START_OUTPUT;
3933 data->REG_PWM[2] = NCT6116_REG_FAN_STOP_OUTPUT;
3934 data->REG_PWM[5] = NCT6106_REG_WEIGHT_DUTY_STEP;
3935 data->REG_PWM[6] = NCT6106_REG_WEIGHT_DUTY_BASE;
3936 data->REG_PWM_READ = NCT6106_REG_PWM_READ;
3937 data->REG_PWM_MODE = NCT6106_REG_PWM_MODE;
3938 data->PWM_MODE_MASK = NCT6106_PWM_MODE_MASK;
3939 data->REG_AUTO_TEMP = NCT6116_REG_AUTO_TEMP;
3940 data->REG_AUTO_PWM = NCT6116_REG_AUTO_PWM;
3941 data->REG_CRITICAL_TEMP = NCT6116_REG_CRITICAL_TEMP;
3942 data->REG_CRITICAL_TEMP_TOLERANCE
3944 data->REG_CRITICAL_PWM_ENABLE = NCT6116_REG_CRITICAL_PWM_ENABLE;
3945 data->CRITICAL_PWM_ENABLE_MASK
3947 data->REG_CRITICAL_PWM = NCT6116_REG_CRITICAL_PWM;
3948 data->REG_TEMP_OFFSET = NCT6106_REG_TEMP_OFFSET;
3949 data->REG_TEMP_SOURCE = NCT6116_REG_TEMP_SOURCE;
3950 data->REG_TEMP_SEL = NCT6116_REG_TEMP_SEL;
3951 data->REG_WEIGHT_TEMP_SEL = NCT6106_REG_WEIGHT_TEMP_SEL;
3952 data->REG_WEIGHT_TEMP[0] = NCT6106_REG_WEIGHT_TEMP_STEP;
3953 data->REG_WEIGHT_TEMP[1] = NCT6106_REG_WEIGHT_TEMP_STEP_TOL;
3954 data->REG_WEIGHT_TEMP[2] = NCT6106_REG_WEIGHT_TEMP_BASE;
3955 data->REG_ALARM = NCT6106_REG_ALARM;
3956 data->ALARM_BITS = NCT6116_ALARM_BITS;
3957 data->REG_BEEP = NCT6106_REG_BEEP;
3958 data->BEEP_BITS = NCT6116_BEEP_BITS;
3974 data->in_num = 9;
3975 data->pwm_num = 3;
3976 data->auto_pwm_num = 6;
3977 data->has_fan_div = true;
3978 data->temp_fixed_num = 3;
3979 data->num_temp_alarms = 3;
3980 data->num_temp_beeps = 3;
3982 data->ALARM_BITS = NCT6775_ALARM_BITS;
3983 data->BEEP_BITS = NCT6775_BEEP_BITS;
3985 data->fan_from_reg = fan_from_reg16;
3986 data->fan_from_reg_min = fan_from_reg8;
3987 data->target_temp_mask = 0x7f;
3988 data->tolerance_mask = 0x0f;
3989 data->speed_tolerance_limit = 15;
3991 data->temp_label = nct6775_temp_label;
3992 data->temp_mask = NCT6775_TEMP_MASK;
3993 data->virt_temp_mask = NCT6775_VIRT_TEMP_MASK;
3995 data->REG_CONFIG = NCT6775_REG_CONFIG;
3996 data->REG_VBAT = NCT6775_REG_VBAT;
3997 data->REG_DIODE = NCT6775_REG_DIODE;
3998 data->DIODE_MASK = NCT6775_DIODE_MASK;
3999 data->REG_VIN = NCT6775_REG_IN;
4000 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
4001 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
4002 data->REG_TARGET = NCT6775_REG_TARGET;
4003 data->REG_FAN = NCT6775_REG_FAN;
4004 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
4005 data->REG_FAN_MIN = NCT6775_REG_FAN_MIN;
4006 data->REG_FAN_PULSES = NCT6775_REG_FAN_PULSES;
4007 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
4008 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
4009 data->REG_FAN_TIME[1] = NCT6775_REG_FAN_STEP_UP_TIME;
4010 data->REG_FAN_TIME[2] = NCT6775_REG_FAN_STEP_DOWN_TIME;
4011 data->REG_PWM[0] = NCT6775_REG_PWM;
4012 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
4013 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
4014 data->REG_PWM[3] = NCT6775_REG_FAN_MAX_OUTPUT;
4015 data->REG_PWM[4] = NCT6775_REG_FAN_STEP_OUTPUT;
4016 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
4017 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
4018 data->REG_PWM_MODE = NCT6775_REG_PWM_MODE;
4019 data->PWM_MODE_MASK = NCT6775_PWM_MODE_MASK;
4020 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
4021 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
4022 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
4023 data->REG_CRITICAL_TEMP_TOLERANCE
4025 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
4026 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
4027 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
4028 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
4029 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
4030 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
4031 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
4032 data->REG_ALARM = NCT6775_REG_ALARM;
4033 data->REG_BEEP = NCT6775_REG_BEEP;
4047 data->in_num = 9;
4048 data->pwm_num = 3;
4049 data->auto_pwm_num = 4;
4050 data->has_fan_div = false;
4051 data->temp_fixed_num = 3;
4052 data->num_temp_alarms = 3;
4053 data->num_temp_beeps = 6;
4055 data->ALARM_BITS = NCT6776_ALARM_BITS;
4056 data->BEEP_BITS = NCT6776_BEEP_BITS;
4058 data->fan_from_reg = fan_from_reg13;
4059 data->fan_from_reg_min = fan_from_reg13;
4060 data->target_temp_mask = 0xff;
4061 data->tolerance_mask = 0x07;
4062 data->speed_tolerance_limit = 63;
4064 data->temp_label = nct6776_temp_label;
4065 data->temp_mask = NCT6776_TEMP_MASK;
4066 data->virt_temp_mask = NCT6776_VIRT_TEMP_MASK;
4068 data->REG_CONFIG = NCT6775_REG_CONFIG;
4069 data->REG_VBAT = NCT6775_REG_VBAT;
4070 data->REG_DIODE = NCT6775_REG_DIODE;
4071 data->DIODE_MASK = NCT6775_DIODE_MASK;
4072 data->REG_VIN = NCT6775_REG_IN;
4073 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
4074 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
4075 data->REG_TARGET = NCT6775_REG_TARGET;
4076 data->REG_FAN = NCT6775_REG_FAN;
4077 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
4078 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
4079 data->REG_FAN_PULSES = NCT6776_REG_FAN_PULSES;
4080 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
4081 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
4082 data->REG_FAN_TIME[1] = NCT6776_REG_FAN_STEP_UP_TIME;
4083 data->REG_FAN_TIME[2] = NCT6776_REG_FAN_STEP_DOWN_TIME;
4084 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
4085 data->REG_PWM[0] = NCT6775_REG_PWM;
4086 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
4087 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
4088 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
4089 data->REG_PWM[6] = NCT6776_REG_WEIGHT_DUTY_BASE;
4090 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
4091 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
4092 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
4093 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
4094 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
4095 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
4096 data->REG_CRITICAL_TEMP_TOLERANCE
4098 data->REG_TEMP_OFFSET = NCT6775_REG_TEMP_OFFSET;
4099 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
4100 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
4101 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
4102 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
4103 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
4104 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
4105 data->REG_ALARM = NCT6775_REG_ALARM;
4106 data->REG_BEEP = NCT6776_REG_BEEP;
4120 data->in_num = 15;
4121 data->pwm_num = 5;
4122 data->auto_pwm_num = 4;
4123 data->has_fan_div = false;
4124 data->temp_fixed_num = 6;
4125 data->num_temp_alarms = 2;
4126 data->num_temp_beeps = 2;
4128 data->ALARM_BITS = NCT6779_ALARM_BITS;
4129 data->BEEP_BITS = NCT6779_BEEP_BITS;
4131 data->fan_from_reg = fan_from_reg_rpm;
4132 data->fan_from_reg_min = fan_from_reg13;
4133 data->target_temp_mask = 0xff;
4134 data->tolerance_mask = 0x07;
4135 data->speed_tolerance_limit = 63;
4137 data->temp_label = nct6779_temp_label;
4138 data->temp_mask = NCT6779_TEMP_MASK;
4139 data->virt_temp_mask = NCT6779_VIRT_TEMP_MASK;
4141 data->REG_CONFIG = NCT6775_REG_CONFIG;
4142 data->REG_VBAT = NCT6775_REG_VBAT;
4143 data->REG_DIODE = NCT6775_REG_DIODE;
4144 data->DIODE_MASK = NCT6775_DIODE_MASK;
4145 data->REG_VIN = NCT6779_REG_IN;
4146 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
4147 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
4148 data->REG_TARGET = NCT6775_REG_TARGET;
4149 data->REG_FAN = NCT6779_REG_FAN;
4150 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
4151 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
4152 data->REG_FAN_PULSES = NCT6779_REG_FAN_PULSES;
4153 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
4154 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
4155 data->REG_FAN_TIME[1] = NCT6776_REG_FAN_STEP_UP_TIME;
4156 data->REG_FAN_TIME[2] = NCT6776_REG_FAN_STEP_DOWN_TIME;
4157 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
4158 data->REG_PWM[0] = NCT6775_REG_PWM;
4159 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
4160 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
4161 data->REG_PWM[5] = NCT6775_REG_WEIGHT_DUTY_STEP;
4162 data->REG_PWM[6] = NCT6776_REG_WEIGHT_DUTY_BASE;
4163 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
4164 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
4165 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
4166 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
4167 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
4168 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
4169 data->REG_CRITICAL_TEMP_TOLERANCE
4171 data->REG_CRITICAL_PWM_ENABLE = NCT6779_REG_CRITICAL_PWM_ENABLE;
4172 data->CRITICAL_PWM_ENABLE_MASK
4174 data->REG_CRITICAL_PWM = NCT6779_REG_CRITICAL_PWM;
4175 data->REG_TEMP_OFFSET = NCT6779_REG_TEMP_OFFSET;
4176 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
4177 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
4178 data->REG_WEIGHT_TEMP_SEL = NCT6775_REG_WEIGHT_TEMP_SEL;
4179 data->REG_WEIGHT_TEMP[0] = NCT6775_REG_WEIGHT_TEMP_STEP;
4180 data->REG_WEIGHT_TEMP[1] = NCT6775_REG_WEIGHT_TEMP_STEP_TOL;
4181 data->REG_WEIGHT_TEMP[2] = NCT6775_REG_WEIGHT_TEMP_BASE;
4182 data->REG_ALARM = NCT6779_REG_ALARM;
4183 data->REG_BEEP = NCT6776_REG_BEEP;
4203 data->in_num = 15;
4204 data->pwm_num = (data->kind == nct6796 ||
4205 data->kind == nct6797 ||
4206 data->kind == nct6798) ? 7 : 6;
4207 data->auto_pwm_num = 4;
4208 data->has_fan_div = false;
4209 data->temp_fixed_num = 6;
4210 data->num_temp_alarms = 2;
4211 data->num_temp_beeps = 2;
4213 data->ALARM_BITS = NCT6791_ALARM_BITS;
4214 data->BEEP_BITS = NCT6779_BEEP_BITS;
4216 data->fan_from_reg = fan_from_reg_rpm;
4217 data->fan_from_reg_min = fan_from_reg13;
4218 data->target_temp_mask = 0xff;
4219 data->tolerance_mask = 0x07;
4220 data->speed_tolerance_limit = 63;
4222 switch (data->kind) {
4225 data->temp_label = nct6779_temp_label;
4226 data->temp_mask = NCT6791_TEMP_MASK;
4227 data->virt_temp_mask = NCT6791_VIRT_TEMP_MASK;
4230 data->temp_label = nct6792_temp_label;
4231 data->temp_mask = NCT6792_TEMP_MASK;
4232 data->virt_temp_mask = NCT6792_VIRT_TEMP_MASK;
4235 data->temp_label = nct6793_temp_label;
4236 data->temp_mask = NCT6793_TEMP_MASK;
4237 data->virt_temp_mask = NCT6793_VIRT_TEMP_MASK;
4241 data->temp_label = nct6795_temp_label;
4242 data->temp_mask = NCT6795_TEMP_MASK;
4243 data->virt_temp_mask = NCT6795_VIRT_TEMP_MASK;
4246 data->temp_label = nct6796_temp_label;
4247 data->temp_mask = NCT6796_TEMP_MASK;
4248 data->virt_temp_mask = NCT6796_VIRT_TEMP_MASK;
4251 data->temp_label = nct6798_temp_label;
4252 data->temp_mask = NCT6798_TEMP_MASK;
4253 data->virt_temp_mask = NCT6798_VIRT_TEMP_MASK;
4257 data->REG_CONFIG = NCT6775_REG_CONFIG;
4258 data->REG_VBAT = NCT6775_REG_VBAT;
4259 data->REG_DIODE = NCT6775_REG_DIODE;
4260 data->DIODE_MASK = NCT6775_DIODE_MASK;
4261 data->REG_VIN = NCT6779_REG_IN;
4262 data->REG_IN_MINMAX[0] = NCT6775_REG_IN_MIN;
4263 data->REG_IN_MINMAX[1] = NCT6775_REG_IN_MAX;
4264 data->REG_TARGET = NCT6775_REG_TARGET;
4265 data->REG_FAN = NCT6779_REG_FAN;
4266 data->REG_FAN_MODE = NCT6775_REG_FAN_MODE;
4267 data->REG_FAN_MIN = NCT6776_REG_FAN_MIN;
4268 data->REG_FAN_PULSES = NCT6779_REG_FAN_PULSES;
4269 data->FAN_PULSE_SHIFT = NCT6775_FAN_PULSE_SHIFT;
4270 data->REG_FAN_TIME[0] = NCT6775_REG_FAN_STOP_TIME;
4271 data->REG_FAN_TIME[1] = NCT6776_REG_FAN_STEP_UP_TIME;
4272 data->REG_FAN_TIME[2] = NCT6776_REG_FAN_STEP_DOWN_TIME;
4273 data->REG_TOLERANCE_H = NCT6776_REG_TOLERANCE_H;
4274 data->REG_PWM[0] = NCT6775_REG_PWM;
4275 data->REG_PWM[1] = NCT6775_REG_FAN_START_OUTPUT;
4276 data->REG_PWM[2] = NCT6775_REG_FAN_STOP_OUTPUT;
4277 data->REG_PWM[5] = NCT6791_REG_WEIGHT_DUTY_STEP;
4278 data->REG_PWM[6] = NCT6791_REG_WEIGHT_DUTY_BASE;
4279 data->REG_PWM_READ = NCT6775_REG_PWM_READ;
4280 data->REG_PWM_MODE = NCT6776_REG_PWM_MODE;
4281 data->PWM_MODE_MASK = NCT6776_PWM_MODE_MASK;
4282 data->REG_AUTO_TEMP = NCT6775_REG_AUTO_TEMP;
4283 data->REG_AUTO_PWM = NCT6775_REG_AUTO_PWM;
4284 data->REG_CRITICAL_TEMP = NCT6775_REG_CRITICAL_TEMP;
4285 data->REG_CRITICAL_TEMP_TOLERANCE
4287 data->REG_CRITICAL_PWM_ENABLE = NCT6779_REG_CRITICAL_PWM_ENABLE;
4288 data->CRITICAL_PWM_ENABLE_MASK
4290 data->REG_CRITICAL_PWM = NCT6779_REG_CRITICAL_PWM;
4291 data->REG_TEMP_OFFSET = NCT6779_REG_TEMP_OFFSET;
4292 data->REG_TEMP_SOURCE = NCT6775_REG_TEMP_SOURCE;
4293 data->REG_TEMP_SEL = NCT6775_REG_TEMP_SEL;
4294 data->REG_WEIGHT_TEMP_SEL = NCT6791_REG_WEIGHT_TEMP_SEL;
4295 data->REG_WEIGHT_TEMP[0] = NCT6791_REG_WEIGHT_TEMP_STEP;
4296 data->REG_WEIGHT_TEMP[1] = NCT6791_REG_WEIGHT_TEMP_STEP_TOL;
4297 data->REG_WEIGHT_TEMP[2] = NCT6791_REG_WEIGHT_TEMP_BASE;
4298 data->REG_ALARM = NCT6791_REG_ALARM;
4299 if (data->kind == nct6791)
4300 data->REG_BEEP = NCT6776_REG_BEEP;
4302 data->REG_BEEP = NCT6792_REG_BEEP;
4306 if (data->kind == nct6791) {
4323 data->have_in = BIT(data->in_num) - 1;
4324 data->have_temp = 0;
4340 src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f;
4351 add_temp_sensors(data, data->REG_TEMP_SEL, &available, &mask);
4352 add_temp_sensors(data, data->REG_WEIGHT_TEMP_SEL, &available, &mask);
4360 src = nct6775_read_value(data, data->REG_TEMP_SOURCE[i]) & 0x1f;
4364 if (!(data->temp_mask & BIT(src))) {
4367 src, i, data->REG_TEMP_SOURCE[i], reg_temp[i]);
4374 if (src <= data->temp_fixed_num) {
4375 data->have_temp |= BIT(src - 1);
4376 data->have_temp_fixed |= BIT(src - 1);
4377 data->reg_temp[0][src - 1] = reg_temp[i];
4378 data->reg_temp[1][src - 1] = reg_temp_over[i];
4379 data->reg_temp[2][src - 1] = reg_temp_hyst[i];
4381 data->reg_temp[3][src - 1] = reg_temp_crit_h[i];
4383 data->reg_temp[3][src - 1]
4386 data->reg_temp[4][src - 1] = reg_temp_crit_l[i];
4387 data->reg_temp_config[src - 1] = reg_temp_config[i];
4388 data->temp_src[src - 1] = src;
4396 data->have_temp |= BIT(s);
4397 data->reg_temp[0][s] = reg_temp[i];
4398 data->reg_temp[1][s] = reg_temp_over[i];
4399 data->reg_temp[2][s] = reg_temp_hyst[i];
4400 data->reg_temp_config[s] = reg_temp_config[i];
4402 data->reg_temp[3][s] = reg_temp_crit_h[i];
4404 data->reg_temp[3][s] = reg_temp_crit[src - 1];
4406 data->reg_temp[4][s] = reg_temp_crit_l[i];
4408 data->temp_src[s] = src;
4420 src = nct6775_read_value(data, data->REG_TEMP_SEL[i]) & 0x1f;
4424 if (!(data->temp_mask & BIT(src))) {
4427 src, i, data->REG_TEMP_SEL[i],
4437 if (!(data->virt_temp_mask & BIT(src))) {
4444 if (src <= data->temp_fixed_num) {
4445 if (data->have_temp & BIT(src - 1))
4447 data->have_temp |= BIT(src - 1);
4448 data->have_temp_fixed |= BIT(src - 1);
4449 data->reg_temp[0][src - 1] = reg_temp_mon[i];
4450 data->temp_src[src - 1] = src;
4458 data->have_temp |= BIT(s);
4459 data->reg_temp[0][s] = reg_temp_mon[i];
4460 data->temp_src[s] = src;
4472 if (!(data->temp_mask & BIT(i + 1)))
4478 if (i < data->temp_fixed_num) {
4479 if (data->have_temp & BIT(i))
4481 data->have_temp |= BIT(i);
4482 data->have_temp_fixed |= BIT(i);
4483 data->reg_temp[0][i] = reg_temp_alternate[i];
4485 data->reg_temp[1][i] = reg_temp_over[i];
4486 data->reg_temp[2][i] = reg_temp_hyst[i];
4488 data->temp_src[i] = i + 1;
4495 data->have_temp |= BIT(s);
4496 data->reg_temp[0][s] = reg_temp_alternate[i];
4497 data->temp_src[s] = i + 1;
4503 nct6775_init_device(data);
4510 switch (data->kind) {
4512 data->have_vid = (cr2a & 0x40);
4515 data->have_vid = (cr2a & 0x60) == 0x40;
4534 if (data->have_vid) {
4536 data->vid = superio_inb(sio_data->sioreg, 0xe3);
4537 data->vrm = vid_which_vrm();
4546 switch (data->kind) {
4571 data->name);
4574 nct6775_check_fan_inputs(data);
4579 nct6775_init_fan_common(dev, data);
4583 data->pwm_num);
4587 data->groups[num_attr_groups++] = group;
4590 fls(data->have_in));
4594 data->groups[num_attr_groups++] = group;
4597 fls(data->has_fan));
4601 data->groups[num_attr_groups++] = group;
4604 fls(data->have_temp));
4608 data->groups[num_attr_groups++] = group;
4609 data->groups[num_attr_groups++] = &nct6775_group_other;
4611 hwmon_dev = devm_hwmon_device_register_with_groups(dev, data->name,
4612 data, data->groups);
4630 struct nct6775_data *data = nct6775_update_device(dev);
4632 mutex_lock(&data->update_lock);
4633 data->vbat = nct6775_read_value(data, data->REG_VBAT);
4634 if (data->kind == nct6775) {
4635 data->fandiv1 = nct6775_read_value(data, NCT6775_REG_FANDIV1);
4636 data->fandiv2 = nct6775_read_value(data, NCT6775_REG_FANDIV2);
4638 mutex_unlock(&data->update_lock);
4645 struct nct6775_data *data = dev_get_drvdata(dev);
4646 int sioreg = data->sioreg;
4650 mutex_lock(&data->update_lock);
4651 data->bank = 0xff; /* Force initial bank selection */
4659 if (reg != data->sio_reg_enable)
4660 superio_outb(sioreg, SIO_REG_ENABLE, data->sio_reg_enable);
4662 if (data->kind == nct6791 || data->kind == nct6792 ||
4663 data->kind == nct6793 || data->kind == nct6795 ||
4664 data->kind == nct6796 || data->kind == nct6797 ||
4665 data->kind == nct6798)
4671 for (i = 0; i < data->in_num; i++) {
4672 if (!(data->have_in & BIT(i)))
4675 nct6775_write_value(data, data->REG_IN_MINMAX[0][i],
4676 data->in[i][1]);
4677 nct6775_write_value(data, data->REG_IN_MINMAX[1][i],
4678 data->in[i][2]);
4681 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
4682 if (!(data->has_fan_min & BIT(i)))
4685 nct6775_write_value(data, data->REG_FAN_MIN[i],
4686 data->fan_min[i]);
4690 if (!(data->have_temp & BIT(i)))
4693 for (j = 1; j < ARRAY_SIZE(data->reg_temp); j++)
4694 if (data->reg_temp[j][i])
4695 nct6775_write_temp(data, data->reg_temp[j][i],
4696 data->temp[j][i]);
4700 nct6775_write_value(data, data->REG_VBAT, data->vbat);
4701 if (data->kind == nct6775) {
4702 nct6775_write_value(data, NCT6775_REG_FANDIV1, data->fandiv1);
4703 nct6775_write_value(data, NCT6775_REG_FANDIV2, data->fandiv2);
4708 data->valid = false;
4709 mutex_unlock(&data->update_lock);