adm1031.c (9806755c56a9a8b3ff8bc9ce3092dcad4d562989) adm1031.c (278ee1c840fcf32f156fd876efcc3780bc580f6c)
1/*
2 * adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
3 * monitoring
4 * Based on lm75.c and lm85.c
5 * Supports adm1030 / adm1031
6 * Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
7 * Reworked by Jean Delvare <jdelvare@suse.de>
8 *

--- 91 unchanged lines hidden (view full) ---

100 u8 auto_temp_off[3];
101 u8 auto_temp_max[3];
102 s8 temp_offset[3];
103 s8 temp_min[3];
104 s8 temp_max[3];
105 s8 temp_crit[3];
106};
107
1/*
2 * adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
3 * monitoring
4 * Based on lm75.c and lm85.c
5 * Supports adm1030 / adm1031
6 * Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
7 * Reworked by Jean Delvare <jdelvare@suse.de>
8 *

--- 91 unchanged lines hidden (view full) ---

100 u8 auto_temp_off[3];
101 u8 auto_temp_max[3];
102 s8 temp_offset[3];
103 s8 temp_min[3];
104 s8 temp_max[3];
105 s8 temp_crit[3];
106};
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)
137{
138 return i2c_smbus_read_byte_data(client, reg);
139}
140
141static inline int
142adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
143{
144 return i2c_smbus_write_byte_data(client, reg, value);
145}
146
108static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
109{
110 return i2c_smbus_read_byte_data(client, reg);
111}
112
113static inline int
114adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
115{
116 return i2c_smbus_write_byte_data(client, reg, value);
117}
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;
147
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}
209
148#define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
149 ((val + 500) / 1000)))
150
151#define TEMP_FROM_REG(val) ((val) * 1000)
152
153#define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
154
155#define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)

--- 789 unchanged lines hidden (view full) ---

945 return -ENODEV;
946 name = (id == 0x30) ? "adm1030" : "adm1031";
947
948 strlcpy(info->type, name, I2C_NAME_SIZE);
949
950 return 0;
951}
952
210#define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
211 ((val + 500) / 1000)))
212
213#define TEMP_FROM_REG(val) ((val) * 1000)
214
215#define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
216
217#define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)

--- 789 unchanged lines hidden (view full) ---

1007 return -ENODEV;
1008 name = (id == 0x30) ? "adm1030" : "adm1031";
1009
1010 strlcpy(info->type, name, I2C_NAME_SIZE);
1011
1012 return 0;
1013}
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,
954 const struct i2c_device_id *id)
955{
956 struct adm1031_data *data;
957 int err;
958
959 data = devm_kzalloc(&client->dev, sizeof(struct adm1031_data),
960 GFP_KERNEL);

--- 42 unchanged lines hidden (view full) ---

1003 struct adm1031_data *data = i2c_get_clientdata(client);
1004
1005 hwmon_device_unregister(data->hwmon_dev);
1006 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
1007 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
1008 return 0;
1009}
1010
1046static int adm1031_probe(struct i2c_client *client,
1047 const struct i2c_device_id *id)
1048{
1049 struct adm1031_data *data;
1050 int err;
1051
1052 data = devm_kzalloc(&client->dev, sizeof(struct adm1031_data),
1053 GFP_KERNEL);

--- 42 unchanged lines hidden (view full) ---

1096 struct adm1031_data *data = i2c_get_clientdata(client);
1097
1098 hwmon_device_unregister(data->hwmon_dev);
1099 sysfs_remove_group(&client->dev.kobj, &adm1031_group);
1100 sysfs_remove_group(&client->dev.kobj, &adm1031_group_opt);
1101 return 0;
1102}
1103
1011static void adm1031_init_client(struct i2c_client *client)
1012{
1013 unsigned int read_val;
1014 unsigned int mask;
1015 int i;
1016 struct adm1031_data *data = i2c_get_clientdata(client);
1104static const struct i2c_device_id adm1031_id[] = {
1105 { "adm1030", adm1030 },
1106 { "adm1031", adm1031 },
1107 { }
1108};
1109MODULE_DEVICE_TABLE(i2c, adm1031_id);
1017
1110
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);
1111static struct i2c_driver adm1031_driver = {
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};
1027
1122
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
1130 return data;
1131}
1132
1133module_i2c_driver(adm1031_driver);
1134
1135MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1136MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1137MODULE_LICENSE("GPL");
1123module_i2c_driver(adm1031_driver);
1124
1125MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1126MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1127MODULE_LICENSE("GPL");