diff options
author | Tokunori Ikegami <ikegami@allied-telesis.co.jp> | 2018-08-07 21:32:16 -0400 |
---|---|---|
committer | Guenter Roeck <linux@roeck-us.net> | 2018-08-10 12:13:01 -0400 |
commit | 5cf943ede4af95313665ea81f224533d2aa272bb (patch) | |
tree | d8ddeb05b111b9092f3f35bfa7bce288668bec81 | |
parent | cd6a2064dbf9e485b80c54687f0ce91cca91a6df (diff) |
hwmon: (adt7475) Split device update function to measure and limits
The update function reads both measurement and limit values.
Those parts can be split so split them for a maintainability.
Signed-off-by: Tokunori Ikegami <ikegami@allied-telesis.co.jp>
Cc: Guenter Roeck <linux@roeck-us.net>
Cc: Chris Packham <chris.packham@alliedtelesis.co.nz>
[groeck: Clarify description]
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
-rw-r--r-- | drivers/hwmon/adt7475.c | 210 |
1 files changed, 109 insertions, 101 deletions
diff --git a/drivers/hwmon/adt7475.c b/drivers/hwmon/adt7475.c index 9ef84998c7f3..d6fe4ddd9927 100644 --- a/drivers/hwmon/adt7475.c +++ b/drivers/hwmon/adt7475.c | |||
@@ -194,7 +194,6 @@ struct adt7475_data { | |||
194 | struct mutex lock; | 194 | struct mutex lock; |
195 | 195 | ||
196 | unsigned long measure_updated; | 196 | unsigned long measure_updated; |
197 | unsigned long limits_updated; | ||
198 | char valid; | 197 | char valid; |
199 | 198 | ||
200 | u8 config4; | 199 | u8 config4; |
@@ -1385,6 +1384,65 @@ static void adt7475_remove_files(struct i2c_client *client, | |||
1385 | sysfs_remove_group(&client->dev.kobj, &vid_attr_group); | 1384 | sysfs_remove_group(&client->dev.kobj, &vid_attr_group); |
1386 | } | 1385 | } |
1387 | 1386 | ||
1387 | static void adt7475_update_limits(struct i2c_client *client) | ||
1388 | { | ||
1389 | struct adt7475_data *data = i2c_get_clientdata(client); | ||
1390 | int i; | ||
1391 | |||
1392 | data->config4 = adt7475_read(REG_CONFIG4); | ||
1393 | data->config5 = adt7475_read(REG_CONFIG5); | ||
1394 | |||
1395 | for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) { | ||
1396 | if (!(data->has_voltage & (1 << i))) | ||
1397 | continue; | ||
1398 | /* Adjust values so they match the input precision */ | ||
1399 | data->voltage[MIN][i] = | ||
1400 | adt7475_read(VOLTAGE_MIN_REG(i)) << 2; | ||
1401 | data->voltage[MAX][i] = | ||
1402 | adt7475_read(VOLTAGE_MAX_REG(i)) << 2; | ||
1403 | } | ||
1404 | |||
1405 | if (data->has_voltage & (1 << 5)) { | ||
1406 | data->voltage[MIN][5] = adt7475_read(REG_VTT_MIN) << 2; | ||
1407 | data->voltage[MAX][5] = adt7475_read(REG_VTT_MAX) << 2; | ||
1408 | } | ||
1409 | |||
1410 | for (i = 0; i < ADT7475_TEMP_COUNT; i++) { | ||
1411 | /* Adjust values so they match the input precision */ | ||
1412 | data->temp[MIN][i] = | ||
1413 | adt7475_read(TEMP_MIN_REG(i)) << 2; | ||
1414 | data->temp[MAX][i] = | ||
1415 | adt7475_read(TEMP_MAX_REG(i)) << 2; | ||
1416 | data->temp[AUTOMIN][i] = | ||
1417 | adt7475_read(TEMP_TMIN_REG(i)) << 2; | ||
1418 | data->temp[THERM][i] = | ||
1419 | adt7475_read(TEMP_THERM_REG(i)) << 2; | ||
1420 | data->temp[OFFSET][i] = | ||
1421 | adt7475_read(TEMP_OFFSET_REG(i)); | ||
1422 | } | ||
1423 | adt7475_read_hystersis(client); | ||
1424 | |||
1425 | for (i = 0; i < ADT7475_TACH_COUNT; i++) { | ||
1426 | if (i == 3 && !data->has_fan4) | ||
1427 | continue; | ||
1428 | data->tach[MIN][i] = | ||
1429 | adt7475_read_word(client, TACH_MIN_REG(i)); | ||
1430 | } | ||
1431 | |||
1432 | for (i = 0; i < ADT7475_PWM_COUNT; i++) { | ||
1433 | if (i == 1 && !data->has_pwm2) | ||
1434 | continue; | ||
1435 | data->pwm[MAX][i] = adt7475_read(PWM_MAX_REG(i)); | ||
1436 | data->pwm[MIN][i] = adt7475_read(PWM_MIN_REG(i)); | ||
1437 | /* Set the channel and control information */ | ||
1438 | adt7475_read_pwm(client, i); | ||
1439 | } | ||
1440 | |||
1441 | data->range[0] = adt7475_read(TEMP_TRANGE_REG(0)); | ||
1442 | data->range[1] = adt7475_read(TEMP_TRANGE_REG(1)); | ||
1443 | data->range[2] = adt7475_read(TEMP_TRANGE_REG(2)); | ||
1444 | } | ||
1445 | |||
1388 | static int adt7475_probe(struct i2c_client *client, | 1446 | static int adt7475_probe(struct i2c_client *client, |
1389 | const struct i2c_device_id *id) | 1447 | const struct i2c_device_id *id) |
1390 | { | 1448 | { |
@@ -1562,6 +1620,9 @@ static int adt7475_probe(struct i2c_client *client, | |||
1562 | (data->bypass_attn & (1 << 3)) ? " in3" : "", | 1620 | (data->bypass_attn & (1 << 3)) ? " in3" : "", |
1563 | (data->bypass_attn & (1 << 4)) ? " in4" : ""); | 1621 | (data->bypass_attn & (1 << 4)) ? " in4" : ""); |
1564 | 1622 | ||
1623 | /* Limits and settings, should never change update more than once */ | ||
1624 | adt7475_update_limits(client); | ||
1625 | |||
1565 | return 0; | 1626 | return 0; |
1566 | 1627 | ||
1567 | eremove: | 1628 | eremove: |
@@ -1658,121 +1719,68 @@ static void adt7475_read_pwm(struct i2c_client *client, int index) | |||
1658 | } | 1719 | } |
1659 | } | 1720 | } |
1660 | 1721 | ||
1661 | static struct adt7475_data *adt7475_update_device(struct device *dev) | 1722 | static void adt7475_update_measure(struct device *dev) |
1662 | { | 1723 | { |
1663 | struct i2c_client *client = to_i2c_client(dev); | 1724 | struct i2c_client *client = to_i2c_client(dev); |
1664 | struct adt7475_data *data = i2c_get_clientdata(client); | 1725 | struct adt7475_data *data = i2c_get_clientdata(client); |
1665 | u16 ext; | 1726 | u16 ext; |
1666 | int i; | 1727 | int i; |
1667 | 1728 | ||
1668 | mutex_lock(&data->lock); | 1729 | data->alarms = adt7475_read(REG_STATUS2) << 8; |
1669 | 1730 | data->alarms |= adt7475_read(REG_STATUS1); | |
1670 | /* Measurement values update every 2 seconds */ | 1731 | |
1671 | if (time_after(jiffies, data->measure_updated + HZ * 2) || | 1732 | ext = (adt7475_read(REG_EXTEND2) << 8) | |
1672 | !data->valid) { | 1733 | adt7475_read(REG_EXTEND1); |
1673 | data->alarms = adt7475_read(REG_STATUS2) << 8; | 1734 | for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) { |
1674 | data->alarms |= adt7475_read(REG_STATUS1); | 1735 | if (!(data->has_voltage & (1 << i))) |
1675 | 1736 | continue; | |
1676 | ext = (adt7475_read(REG_EXTEND2) << 8) | | 1737 | data->voltage[INPUT][i] = |
1677 | adt7475_read(REG_EXTEND1); | 1738 | (adt7475_read(VOLTAGE_REG(i)) << 2) | |
1678 | for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) { | 1739 | ((ext >> (i * 2)) & 3); |
1679 | if (!(data->has_voltage & (1 << i))) | 1740 | } |
1680 | continue; | ||
1681 | data->voltage[INPUT][i] = | ||
1682 | (adt7475_read(VOLTAGE_REG(i)) << 2) | | ||
1683 | ((ext >> (i * 2)) & 3); | ||
1684 | } | ||
1685 | |||
1686 | for (i = 0; i < ADT7475_TEMP_COUNT; i++) | ||
1687 | data->temp[INPUT][i] = | ||
1688 | (adt7475_read(TEMP_REG(i)) << 2) | | ||
1689 | ((ext >> ((i + 5) * 2)) & 3); | ||
1690 | |||
1691 | if (data->has_voltage & (1 << 5)) { | ||
1692 | data->alarms |= adt7475_read(REG_STATUS4) << 24; | ||
1693 | ext = adt7475_read(REG_EXTEND3); | ||
1694 | data->voltage[INPUT][5] = adt7475_read(REG_VTT) << 2 | | ||
1695 | ((ext >> 4) & 3); | ||
1696 | } | ||
1697 | |||
1698 | for (i = 0; i < ADT7475_TACH_COUNT; i++) { | ||
1699 | if (i == 3 && !data->has_fan4) | ||
1700 | continue; | ||
1701 | data->tach[INPUT][i] = | ||
1702 | adt7475_read_word(client, TACH_REG(i)); | ||
1703 | } | ||
1704 | |||
1705 | /* Updated by hw when in auto mode */ | ||
1706 | for (i = 0; i < ADT7475_PWM_COUNT; i++) { | ||
1707 | if (i == 1 && !data->has_pwm2) | ||
1708 | continue; | ||
1709 | data->pwm[INPUT][i] = adt7475_read(PWM_REG(i)); | ||
1710 | } | ||
1711 | 1741 | ||
1712 | if (data->has_vid) | 1742 | for (i = 0; i < ADT7475_TEMP_COUNT; i++) |
1713 | data->vid = adt7475_read(REG_VID) & 0x3f; | 1743 | data->temp[INPUT][i] = |
1744 | (adt7475_read(TEMP_REG(i)) << 2) | | ||
1745 | ((ext >> ((i + 5) * 2)) & 3); | ||
1714 | 1746 | ||
1715 | data->measure_updated = jiffies; | 1747 | if (data->has_voltage & (1 << 5)) { |
1748 | data->alarms |= adt7475_read(REG_STATUS4) << 24; | ||
1749 | ext = adt7475_read(REG_EXTEND3); | ||
1750 | data->voltage[INPUT][5] = adt7475_read(REG_VTT) << 2 | | ||
1751 | ((ext >> 4) & 3); | ||
1716 | } | 1752 | } |
1717 | 1753 | ||
1718 | /* Limits and settings, should never change update every 60 seconds */ | 1754 | for (i = 0; i < ADT7475_TACH_COUNT; i++) { |
1719 | if (time_after(jiffies, data->limits_updated + HZ * 60) || | 1755 | if (i == 3 && !data->has_fan4) |
1720 | !data->valid) { | 1756 | continue; |
1721 | data->config4 = adt7475_read(REG_CONFIG4); | 1757 | data->tach[INPUT][i] = |
1722 | data->config5 = adt7475_read(REG_CONFIG5); | 1758 | adt7475_read_word(client, TACH_REG(i)); |
1723 | 1759 | } | |
1724 | for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) { | ||
1725 | if (!(data->has_voltage & (1 << i))) | ||
1726 | continue; | ||
1727 | /* Adjust values so they match the input precision */ | ||
1728 | data->voltage[MIN][i] = | ||
1729 | adt7475_read(VOLTAGE_MIN_REG(i)) << 2; | ||
1730 | data->voltage[MAX][i] = | ||
1731 | adt7475_read(VOLTAGE_MAX_REG(i)) << 2; | ||
1732 | } | ||
1733 | |||
1734 | if (data->has_voltage & (1 << 5)) { | ||
1735 | data->voltage[MIN][5] = adt7475_read(REG_VTT_MIN) << 2; | ||
1736 | data->voltage[MAX][5] = adt7475_read(REG_VTT_MAX) << 2; | ||
1737 | } | ||
1738 | 1760 | ||
1739 | for (i = 0; i < ADT7475_TEMP_COUNT; i++) { | 1761 | /* Updated by hw when in auto mode */ |
1740 | /* Adjust values so they match the input precision */ | 1762 | for (i = 0; i < ADT7475_PWM_COUNT; i++) { |
1741 | data->temp[MIN][i] = | 1763 | if (i == 1 && !data->has_pwm2) |
1742 | adt7475_read(TEMP_MIN_REG(i)) << 2; | 1764 | continue; |
1743 | data->temp[MAX][i] = | 1765 | data->pwm[INPUT][i] = adt7475_read(PWM_REG(i)); |
1744 | adt7475_read(TEMP_MAX_REG(i)) << 2; | 1766 | } |
1745 | data->temp[AUTOMIN][i] = | ||
1746 | adt7475_read(TEMP_TMIN_REG(i)) << 2; | ||
1747 | data->temp[THERM][i] = | ||
1748 | adt7475_read(TEMP_THERM_REG(i)) << 2; | ||
1749 | data->temp[OFFSET][i] = | ||
1750 | adt7475_read(TEMP_OFFSET_REG(i)); | ||
1751 | } | ||
1752 | adt7475_read_hystersis(client); | ||
1753 | 1767 | ||
1754 | for (i = 0; i < ADT7475_TACH_COUNT; i++) { | 1768 | if (data->has_vid) |
1755 | if (i == 3 && !data->has_fan4) | 1769 | data->vid = adt7475_read(REG_VID) & 0x3f; |
1756 | continue; | 1770 | } |
1757 | data->tach[MIN][i] = | ||
1758 | adt7475_read_word(client, TACH_MIN_REG(i)); | ||
1759 | } | ||
1760 | 1771 | ||
1761 | for (i = 0; i < ADT7475_PWM_COUNT; i++) { | 1772 | static struct adt7475_data *adt7475_update_device(struct device *dev) |
1762 | if (i == 1 && !data->has_pwm2) | 1773 | { |
1763 | continue; | 1774 | struct i2c_client *client = to_i2c_client(dev); |
1764 | data->pwm[MAX][i] = adt7475_read(PWM_MAX_REG(i)); | 1775 | struct adt7475_data *data = i2c_get_clientdata(client); |
1765 | data->pwm[MIN][i] = adt7475_read(PWM_MIN_REG(i)); | ||
1766 | /* Set the channel and control information */ | ||
1767 | adt7475_read_pwm(client, i); | ||
1768 | } | ||
1769 | 1776 | ||
1770 | data->range[0] = adt7475_read(TEMP_TRANGE_REG(0)); | 1777 | mutex_lock(&data->lock); |
1771 | data->range[1] = adt7475_read(TEMP_TRANGE_REG(1)); | ||
1772 | data->range[2] = adt7475_read(TEMP_TRANGE_REG(2)); | ||
1773 | 1778 | ||
1774 | data->limits_updated = jiffies; | 1779 | /* Measurement values update every 2 seconds */ |
1775 | data->valid = 1; | 1780 | if (time_after(jiffies, data->measure_updated + HZ * 2) || |
1781 | !data->valid) { | ||
1782 | adt7475_update_measure(dev); | ||
1783 | data->measure_updated = jiffies; | ||
1776 | } | 1784 | } |
1777 | 1785 | ||
1778 | mutex_unlock(&data->lock); | 1786 | mutex_unlock(&data->lock); |