1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/module.h>
28#include <linux/init.h>
29#include <linux/slab.h>
30#include <linux/i2c.h>
31#include <linux/hwmon.h>
32#include <linux/hwmon-sysfs.h>
33#include <linux/err.h>
34#include <linux/sysfs.h>
35#include <linux/mutex.h>
36
37#define THERMAL_PID_REG 0xfd
38#define THERMAL_SMSC_ID_REG 0xfe
39#define THERMAL_REVISION_REG 0xff
40
41struct thermal_data {
42 struct device *hwmon_dev;
43 struct mutex mutex;
44
45
46 u8 cached_hyst;
47 unsigned long hyst_valid;
48};
49
50static ssize_t show_temp(struct device *dev,
51 struct device_attribute *attr, char *buf)
52{
53 struct i2c_client *client = to_i2c_client(dev);
54 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
55 int retval = i2c_smbus_read_byte_data(client, sda->index);
56
57 if (retval < 0)
58 return retval;
59 return sprintf(buf, "%d000\n", retval);
60}
61
62static ssize_t show_bit(struct device *dev,
63 struct device_attribute *attr, char *buf)
64{
65 struct i2c_client *client = to_i2c_client(dev);
66 struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr);
67 int retval = i2c_smbus_read_byte_data(client, sda->nr);
68
69 if (retval < 0)
70 return retval;
71 retval &= sda->index;
72 return sprintf(buf, "%d\n", retval ? 1 : 0);
73}
74
75static ssize_t store_temp(struct device *dev,
76 struct device_attribute *attr, const char *buf, size_t count)
77{
78 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
79 struct i2c_client *client = to_i2c_client(dev);
80 unsigned long val;
81 int retval;
82
83 if (strict_strtoul(buf, 10, &val))
84 return -EINVAL;
85 retval = i2c_smbus_write_byte_data(client, sda->index,
86 DIV_ROUND_CLOSEST(val, 1000));
87 if (retval < 0)
88 return retval;
89 return count;
90}
91
92static ssize_t store_bit(struct device *dev,
93 struct device_attribute *attr, const char *buf, size_t count)
94{
95 struct i2c_client *client = to_i2c_client(dev);
96 struct thermal_data *data = i2c_get_clientdata(client);
97 struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr);
98 unsigned long val;
99 int retval;
100
101 if (strict_strtoul(buf, 10, &val))
102 return -EINVAL;
103
104 mutex_lock(&data->mutex);
105 retval = i2c_smbus_read_byte_data(client, sda->nr);
106 if (retval < 0)
107 goto fail;
108
109 retval &= ~sda->index;
110 if (val)
111 retval |= sda->index;
112
113 retval = i2c_smbus_write_byte_data(client, sda->index, retval);
114 if (retval == 0)
115 retval = count;
116fail:
117 mutex_unlock(&data->mutex);
118 return retval;
119}
120
121static ssize_t show_hyst(struct device *dev,
122 struct device_attribute *attr, char *buf)
123{
124 struct i2c_client *client = to_i2c_client(dev);
125 struct thermal_data *data = i2c_get_clientdata(client);
126 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
127 int retval;
128 int hyst;
129
130 retval = i2c_smbus_read_byte_data(client, sda->index);
131 if (retval < 0)
132 return retval;
133
134 if (time_after(jiffies, data->hyst_valid)) {
135 hyst = i2c_smbus_read_byte_data(client, 0x21);
136 if (hyst < 0)
137 return retval;
138 data->cached_hyst = hyst;
139 data->hyst_valid = jiffies + HZ;
140 }
141 return sprintf(buf, "%d000\n", retval - data->cached_hyst);
142}
143
144static ssize_t store_hyst(struct device *dev,
145 struct device_attribute *attr, const char *buf, size_t count)
146{
147 struct i2c_client *client = to_i2c_client(dev);
148 struct thermal_data *data = i2c_get_clientdata(client);
149 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
150 int retval;
151 int hyst;
152 unsigned long val;
153
154 if (strict_strtoul(buf, 10, &val))
155 return -EINVAL;
156
157 mutex_lock(&data->mutex);
158 retval = i2c_smbus_read_byte_data(client, sda->index);
159 if (retval < 0)
160 goto fail;
161
162 hyst = val - retval * 1000;
163 hyst = DIV_ROUND_CLOSEST(hyst, 1000);
164 if (hyst < 0 || hyst > 255) {
165 retval = -ERANGE;
166 goto fail;
167 }
168
169 retval = i2c_smbus_write_byte_data(client, 0x21, hyst);
170 if (retval == 0) {
171 retval = count;
172 data->cached_hyst = hyst;
173 data->hyst_valid = jiffies + HZ;
174 }
175fail:
176 mutex_unlock(&data->mutex);
177 return retval;
178}
179
180
181
182
183
184static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR,
185 show_temp, store_temp, 0x06);
186static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
187 show_temp, store_temp, 0x05);
188static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR,
189 show_temp, store_temp, 0x20);
190static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0x00);
191static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO,
192 show_bit, NULL, 0x36, 0x01);
193static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO,
194 show_bit, NULL, 0x35, 0x01);
195static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO,
196 show_bit, NULL, 0x37, 0x01);
197static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR,
198 show_hyst, store_hyst, 0x20);
199
200static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR,
201 show_temp, store_temp, 0x08);
202static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
203 show_temp, store_temp, 0x07);
204static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR,
205 show_temp, store_temp, 0x19);
206static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0x01);
207static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO,
208 show_bit, NULL, 0x36, 0x02);
209static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO,
210 show_bit, NULL, 0x35, 0x02);
211static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO,
212 show_bit, NULL, 0x37, 0x02);
213static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO | S_IWUSR,
214 show_hyst, store_hyst, 0x19);
215
216static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR,
217 show_temp, store_temp, 0x16);
218static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR,
219 show_temp, store_temp, 0x15);
220static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO | S_IWUSR,
221 show_temp, store_temp, 0x1A);
222static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 0x23);
223static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO,
224 show_bit, NULL, 0x36, 0x04);
225static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO,
226 show_bit, NULL, 0x35, 0x04);
227static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO,
228 show_bit, NULL, 0x37, 0x04);
229static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO | S_IWUSR,
230 show_hyst, store_hyst, 0x1A);
231
232static SENSOR_DEVICE_ATTR_2(power_state, S_IRUGO | S_IWUSR,
233 show_bit, store_bit, 0x03, 0x40);
234
235static struct attribute *mid_att_thermal[] = {
236 &sensor_dev_attr_temp1_min.dev_attr.attr,
237 &sensor_dev_attr_temp1_max.dev_attr.attr,
238 &sensor_dev_attr_temp1_crit.dev_attr.attr,
239 &sensor_dev_attr_temp1_input.dev_attr.attr,
240 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
241 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
242 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
243 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
244 &sensor_dev_attr_temp2_min.dev_attr.attr,
245 &sensor_dev_attr_temp2_max.dev_attr.attr,
246 &sensor_dev_attr_temp2_crit.dev_attr.attr,
247 &sensor_dev_attr_temp2_input.dev_attr.attr,
248 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
249 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
250 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
251 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
252 &sensor_dev_attr_temp3_min.dev_attr.attr,
253 &sensor_dev_attr_temp3_max.dev_attr.attr,
254 &sensor_dev_attr_temp3_crit.dev_attr.attr,
255 &sensor_dev_attr_temp3_input.dev_attr.attr,
256 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
257 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
258 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
259 &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
260 &sensor_dev_attr_power_state.dev_attr.attr,
261 NULL
262};
263
264static const struct attribute_group m_thermal_gr = {
265 .attrs = mid_att_thermal
266};
267
268static int emc1403_detect(struct i2c_client *client,
269 struct i2c_board_info *info)
270{
271 int id;
272
273
274 id = i2c_smbus_read_byte_data(client, THERMAL_SMSC_ID_REG);
275 if (id != 0x5d)
276 return -ENODEV;
277
278 id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG);
279 switch (id) {
280 case 0x21:
281 strlcpy(info->type, "emc1403", I2C_NAME_SIZE);
282 break;
283 case 0x23:
284 strlcpy(info->type, "emc1423", I2C_NAME_SIZE);
285 break;
286
287
288 default:
289 return -ENODEV;
290 }
291
292 id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG);
293 if (id != 0x01)
294 return -ENODEV;
295
296 return 0;
297}
298
299static int emc1403_probe(struct i2c_client *client,
300 const struct i2c_device_id *id)
301{
302 int res;
303 struct thermal_data *data;
304
305 data = kzalloc(sizeof(struct thermal_data), GFP_KERNEL);
306 if (data == NULL) {
307 dev_warn(&client->dev, "out of memory");
308 return -ENOMEM;
309 }
310
311 i2c_set_clientdata(client, data);
312 mutex_init(&data->mutex);
313 data->hyst_valid = jiffies - 1;
314
315 res = sysfs_create_group(&client->dev.kobj, &m_thermal_gr);
316 if (res) {
317 dev_warn(&client->dev, "create group failed\n");
318 goto thermal_error1;
319 }
320 data->hwmon_dev = hwmon_device_register(&client->dev);
321 if (IS_ERR(data->hwmon_dev)) {
322 res = PTR_ERR(data->hwmon_dev);
323 dev_warn(&client->dev, "register hwmon dev failed\n");
324 goto thermal_error2;
325 }
326 dev_info(&client->dev, "EMC1403 Thermal chip found\n");
327 return res;
328
329thermal_error2:
330 sysfs_remove_group(&client->dev.kobj, &m_thermal_gr);
331thermal_error1:
332 kfree(data);
333 return res;
334}
335
336static int emc1403_remove(struct i2c_client *client)
337{
338 struct thermal_data *data = i2c_get_clientdata(client);
339
340 hwmon_device_unregister(data->hwmon_dev);
341 sysfs_remove_group(&client->dev.kobj, &m_thermal_gr);
342 kfree(data);
343 return 0;
344}
345
346static const unsigned short emc1403_address_list[] = {
347 0x18, 0x29, 0x4c, 0x4d, I2C_CLIENT_END
348};
349
350static const struct i2c_device_id emc1403_idtable[] = {
351 { "emc1403", 0 },
352 { "emc1423", 0 },
353 { }
354};
355MODULE_DEVICE_TABLE(i2c, emc1403_idtable);
356
357static struct i2c_driver sensor_emc1403 = {
358 .class = I2C_CLASS_HWMON,
359 .driver = {
360 .name = "emc1403",
361 },
362 .detect = emc1403_detect,
363 .probe = emc1403_probe,
364 .remove = emc1403_remove,
365 .id_table = emc1403_idtable,
366 .address_list = emc1403_address_list,
367};
368
369static int __init sensor_emc1403_init(void)
370{
371 return i2c_add_driver(&sensor_emc1403);
372}
373
374static void __exit sensor_emc1403_exit(void)
375{
376 i2c_del_driver(&sensor_emc1403);
377}
378
379module_init(sensor_emc1403_init);
380module_exit(sensor_emc1403_exit);
381
382MODULE_AUTHOR("Kalhan Trisal <kalhan.trisal@intel.com");
383MODULE_DESCRIPTION("emc1403 Thermal Driver");
384MODULE_LICENSE("GPL v2");
385
