aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hwmon
diff options
context:
space:
mode:
authorAxel Lin <axel.lin@ingics.com>2014-07-03 09:56:33 -0400
committerGuenter Roeck <linux@roeck-us.net>2014-08-04 10:01:37 -0400
commit278ee1c840fcf32f156fd876efcc3780bc580f6c (patch)
treed4f0790e08dc9cfb28bd6efa5d61843cee82e083 /drivers/hwmon
parentb591d3c1964e7cba6582eb22c7033d37c31a4e99 (diff)
hwmon: (adm1031) Avoid forward declaration
Reorder functions to avoid forward declaration. Signed-off-by: Axel Lin <axel.lin@ingics.com> Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Diffstat (limited to 'drivers/hwmon')
-rw-r--r--drivers/hwmon/adm1031.c286
1 files changed, 138 insertions, 148 deletions
diff --git a/drivers/hwmon/adm1031.c b/drivers/hwmon/adm1031.c
index 51c1a5a165ab..9f3cb80a17c7 100644
--- a/drivers/hwmon/adm1031.c
+++ b/drivers/hwmon/adm1031.c
@@ -105,34 +105,6 @@ struct adm1031_data {
105 s8 temp_crit[3]; 105 s8 temp_crit[3];
106}; 106};
107 107
108static int adm1031_probe(struct i2c_client *client,
109 const struct i2c_device_id *id);
110static int adm1031_detect(struct i2c_client *client,
111 struct i2c_board_info *info);
112static void adm1031_init_client(struct i2c_client *client);
113static int adm1031_remove(struct i2c_client *client);
114static struct adm1031_data *adm1031_update_device(struct device *dev);
115
116static const struct i2c_device_id adm1031_id[] = {
117 { "adm1030", adm1030 },
118 { "adm1031", adm1031 },
119 { }
120};
121MODULE_DEVICE_TABLE(i2c, adm1031_id);
122
123/* This is the driver that will be inserted */
124static struct i2c_driver adm1031_driver = {
125 .class = I2C_CLASS_HWMON,
126 .driver = {
127 .name = "adm1031",
128 },
129 .probe = adm1031_probe,
130 .remove = adm1031_remove,
131 .id_table = adm1031_id,
132 .detect = adm1031_detect,
133 .address_list = normal_i2c,
134};
135
136static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg) 108static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
137{ 109{
138 return i2c_smbus_read_byte_data(client, reg); 110 return i2c_smbus_read_byte_data(client, reg);
@@ -144,6 +116,96 @@ adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
144 return i2c_smbus_write_byte_data(client, reg, value); 116 return i2c_smbus_write_byte_data(client, reg, value);
145} 117}
146 118
119static struct adm1031_data *adm1031_update_device(struct device *dev)
120{
121 struct i2c_client *client = to_i2c_client(dev);
122 struct adm1031_data *data = i2c_get_clientdata(client);
123 unsigned long next_update;
124 int chan;
125
126 mutex_lock(&data->update_lock);
127
128 next_update = data->last_updated
129 + msecs_to_jiffies(data->update_interval);
130 if (time_after(jiffies, next_update) || !data->valid) {
131
132 dev_dbg(&client->dev, "Starting adm1031 update\n");
133 for (chan = 0;
134 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
135 u8 oldh, newh;
136
137 oldh =
138 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
139 data->ext_temp[chan] =
140 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
141 newh =
142 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
143 if (newh != oldh) {
144 data->ext_temp[chan] =
145 adm1031_read_value(client,
146 ADM1031_REG_EXT_TEMP);
147#ifdef DEBUG
148 oldh =
149 adm1031_read_value(client,
150 ADM1031_REG_TEMP(chan));
151
152 /* oldh is actually newer */
153 if (newh != oldh)
154 dev_warn(&client->dev,
155 "Remote temperature may be wrong.\n");
156#endif
157 }
158 data->temp[chan] = newh;
159
160 data->temp_offset[chan] =
161 adm1031_read_value(client,
162 ADM1031_REG_TEMP_OFFSET(chan));
163 data->temp_min[chan] =
164 adm1031_read_value(client,
165 ADM1031_REG_TEMP_MIN(chan));
166 data->temp_max[chan] =
167 adm1031_read_value(client,
168 ADM1031_REG_TEMP_MAX(chan));
169 data->temp_crit[chan] =
170 adm1031_read_value(client,
171 ADM1031_REG_TEMP_CRIT(chan));
172 data->auto_temp[chan] =
173 adm1031_read_value(client,
174 ADM1031_REG_AUTO_TEMP(chan));
175
176 }
177
178 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
179 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
180
181 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
182 | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
183 if (data->chip_type == adm1030)
184 data->alarm &= 0xc0ff;
185
186 for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
187 chan++) {
188 data->fan_div[chan] =
189 adm1031_read_value(client,
190 ADM1031_REG_FAN_DIV(chan));
191 data->fan_min[chan] =
192 adm1031_read_value(client,
193 ADM1031_REG_FAN_MIN(chan));
194 data->fan[chan] =
195 adm1031_read_value(client,
196 ADM1031_REG_FAN_SPEED(chan));
197 data->pwm[chan] =
198 (adm1031_read_value(client,
199 ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
200 }
201 data->last_updated = jiffies;
202 data->valid = 1;
203 }
204
205 mutex_unlock(&data->update_lock);
206
207 return data;
208}
147 209
148#define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \ 210#define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
149 ((val + 500) / 1000))) 211 ((val + 500) / 1000)))
@@ -950,6 +1012,37 @@ static int adm1031_detect(struct i2c_client *client,
950 return 0; 1012 return 0;
951} 1013}
952 1014
1015static void adm1031_init_client(struct i2c_client *client)
1016{
1017 unsigned int read_val;
1018 unsigned int mask;
1019 int i;
1020 struct adm1031_data *data = i2c_get_clientdata(client);
1021
1022 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1023 if (data->chip_type == adm1031) {
1024 mask |= (ADM1031_CONF2_PWM2_ENABLE |
1025 ADM1031_CONF2_TACH2_ENABLE);
1026 }
1027 /* Initialize the ADM1031 chip (enables fan speed reading ) */
1028 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1029 if ((read_val | mask) != read_val)
1030 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1031
1032 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1033 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1034 adm1031_write_value(client, ADM1031_REG_CONF1,
1035 read_val | ADM1031_CONF1_MONITOR_ENABLE);
1036 }
1037
1038 /* Read the chip's update rate */
1039 mask = ADM1031_UPDATE_RATE_MASK;
1040 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1041 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1042 /* Save it as update interval */
1043 data->update_interval = update_intervals[i];
1044}
1045
953static int adm1031_probe(struct i2c_client *client, 1046static int adm1031_probe(struct i2c_client *client,
954 const struct i2c_device_id *id) 1047 const struct i2c_device_id *id)
955{ 1048{
@@ -1008,127 +1101,24 @@ static int adm1031_remove(struct i2c_client *client)
1008 return 0; 1101 return 0;
1009} 1102}
1010 1103
1011static void adm1031_init_client(struct i2c_client *client) 1104static const struct i2c_device_id adm1031_id[] = {
1012{ 1105 { "adm1030", adm1030 },
1013 unsigned int read_val; 1106 { "adm1031", adm1031 },
1014 unsigned int mask; 1107 { }
1015 int i; 1108};
1016 struct adm1031_data *data = i2c_get_clientdata(client); 1109MODULE_DEVICE_TABLE(i2c, adm1031_id);
1017
1018 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1019 if (data->chip_type == adm1031) {
1020 mask |= (ADM1031_CONF2_PWM2_ENABLE |
1021 ADM1031_CONF2_TACH2_ENABLE);
1022 }
1023 /* Initialize the ADM1031 chip (enables fan speed reading ) */
1024 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1025 if ((read_val | mask) != read_val)
1026 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1027
1028 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1029 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1030 adm1031_write_value(client, ADM1031_REG_CONF1,
1031 read_val | ADM1031_CONF1_MONITOR_ENABLE);
1032 }
1033
1034 /* Read the chip's update rate */
1035 mask = ADM1031_UPDATE_RATE_MASK;
1036 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1037 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1038 /* Save it as update interval */
1039 data->update_interval = update_intervals[i];
1040}
1041
1042static struct adm1031_data *adm1031_update_device(struct device *dev)
1043{
1044 struct i2c_client *client = to_i2c_client(dev);
1045 struct adm1031_data *data = i2c_get_clientdata(client);
1046 unsigned long next_update;
1047 int chan;
1048
1049 mutex_lock(&data->update_lock);
1050
1051 next_update = data->last_updated
1052 + msecs_to_jiffies(data->update_interval);
1053 if (time_after(jiffies, next_update) || !data->valid) {
1054
1055 dev_dbg(&client->dev, "Starting adm1031 update\n");
1056 for (chan = 0;
1057 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
1058 u8 oldh, newh;
1059
1060 oldh =
1061 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1062 data->ext_temp[chan] =
1063 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
1064 newh =
1065 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
1066 if (newh != oldh) {
1067 data->ext_temp[chan] =
1068 adm1031_read_value(client,
1069 ADM1031_REG_EXT_TEMP);
1070#ifdef DEBUG
1071 oldh =
1072 adm1031_read_value(client,
1073 ADM1031_REG_TEMP(chan));
1074
1075 /* oldh is actually newer */
1076 if (newh != oldh)
1077 dev_warn(&client->dev,
1078 "Remote temperature may be wrong.\n");
1079#endif
1080 }
1081 data->temp[chan] = newh;
1082
1083 data->temp_offset[chan] =
1084 adm1031_read_value(client,
1085 ADM1031_REG_TEMP_OFFSET(chan));
1086 data->temp_min[chan] =
1087 adm1031_read_value(client,
1088 ADM1031_REG_TEMP_MIN(chan));
1089 data->temp_max[chan] =
1090 adm1031_read_value(client,
1091 ADM1031_REG_TEMP_MAX(chan));
1092 data->temp_crit[chan] =
1093 adm1031_read_value(client,
1094 ADM1031_REG_TEMP_CRIT(chan));
1095 data->auto_temp[chan] =
1096 adm1031_read_value(client,
1097 ADM1031_REG_AUTO_TEMP(chan));
1098
1099 }
1100
1101 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
1102 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
1103
1104 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
1105 | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
1106 if (data->chip_type == adm1030)
1107 data->alarm &= 0xc0ff;
1108
1109 for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
1110 chan++) {
1111 data->fan_div[chan] =
1112 adm1031_read_value(client,
1113 ADM1031_REG_FAN_DIV(chan));
1114 data->fan_min[chan] =
1115 adm1031_read_value(client,
1116 ADM1031_REG_FAN_MIN(chan));
1117 data->fan[chan] =
1118 adm1031_read_value(client,
1119 ADM1031_REG_FAN_SPEED(chan));
1120 data->pwm[chan] =
1121 (adm1031_read_value(client,
1122 ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
1123 }
1124 data->last_updated = jiffies;
1125 data->valid = 1;
1126 }
1127
1128 mutex_unlock(&data->update_lock);
1129 1110
1130 return data; 1111static struct i2c_driver adm1031_driver = {
1131} 1112 .class = I2C_CLASS_HWMON,
1113 .driver = {
1114 .name = "adm1031",
1115 },
1116 .probe = adm1031_probe,
1117 .remove = adm1031_remove,
1118 .id_table = adm1031_id,
1119 .detect = adm1031_detect,
1120 .address_list = normal_i2c,
1121};
1132 1122
1133module_i2c_driver(adm1031_driver); 1123module_i2c_driver(adm1031_driver);
1134 1124
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-19 12:29:36 -0500