2 * Copyright (C) rockchip 2014
3 * Author:zhangqing <zhangqing@rock-chips.com>
5 * License Terms: GNU General Public License v2
7 * rockchip tsadc does not provide auto tsADC, so to monitor the required temperatures,
8 * a periodic work is used. It is more important to not wake up the CPU than
9 * to perform this job, hence the use of a deferred delay.
13 #include <linux/err.h>
14 #include <linux/hwmon.h>
15 #include <linux/hwmon-sysfs.h>
16 #include <linux/interrupt.h>
17 #include <linux/jiffies.h>
18 #include <linux/module.h>
19 #include <linux/mutex.h>
21 #include <linux/platform_device.h>
23 #include <linux/slab.h>
24 #include <linux/sysfs.h>
25 #include <linux/workqueue.h>
26 #include "hwmon-rockchip.h"
29 #define DEFAULT_MONITOR_DELAY HZ
30 #define DEFAULT_MAX_TEMP 130
32 static inline void schedule_monitor(struct rockchip_temp *data)
34 data->work_active = true;
35 schedule_delayed_work(&data->work, DEFAULT_MONITOR_DELAY);
38 static void threshold_updated(struct rockchip_temp *data)
41 for (i = 0; i < data->monitored_sensors; i++)
42 if (data->max[i] != 0 || data->min[i] != 0) {
43 schedule_monitor(data);
47 dev_dbg(&data->pdev->dev, "No active thresholds.\n");
48 cancel_delayed_work_sync(&data->work);
49 data->work_active = false;
52 static void tsadc_monitor(struct work_struct *work)
56 bool updated_min_alarm, updated_max_alarm;
57 struct rockchip_temp *data;
59 data = container_of(work, struct rockchip_temp, work.work);
60 mutex_lock(&data->lock);
62 for (i = 0; i < data->monitored_sensors; i++) {
63 /* Thresholds are considered inactive if set to 0 */
64 if (data->max[i] == 0 && data->min[i] == 0)
67 if (data->max[i] < data->min[i])
70 temp = data->ops.read_sensor(data->tsadc_addr[i]);
72 dev_err(&data->pdev->dev, "TSADC read failed\n");
76 updated_min_alarm = false;
77 updated_max_alarm = false;
79 if (data->min[i] != 0) {
80 if (temp < data->min[i]) {
81 if (data->min_alarm[i] == false) {
82 data->min_alarm[i] = true;
83 updated_min_alarm = true;
86 if (data->min_alarm[i] == true) {
87 data->min_alarm[i] = false;
88 updated_min_alarm = true;
92 if (data->max[i] != 0) {
93 if (temp > data->max[i]) {
94 if (data->max_alarm[i] == false) {
95 data->max_alarm[i] = true;
96 updated_max_alarm = true;
98 } else if (temp < data->max[i] - data->max_hyst[i]) {
99 if (data->max_alarm[i] == true) {
100 data->max_alarm[i] = false;
101 updated_max_alarm = true;
106 if (updated_min_alarm) {
107 ret = sprintf(alarm_node, "temp%d_min_alarm", i + 1);
108 sysfs_notify(&data->pdev->dev.kobj, NULL, alarm_node);
110 if (updated_max_alarm) {
111 ret = sprintf(alarm_node, "temp%d_max_alarm", i + 1);
112 sysfs_notify(&data->pdev->dev.kobj, NULL, alarm_node);
116 schedule_monitor(data);
117 mutex_unlock(&data->lock);
120 /* HWMON sysfs interfaces */
121 static ssize_t show_name(struct device *dev, struct device_attribute *devattr,
124 struct rockchip_temp *data = dev_get_drvdata(dev);
126 return data->ops.show_name(dev, devattr, buf);
129 static ssize_t show_label(struct device *dev,
130 struct device_attribute *devattr, char *buf)
132 struct rockchip_temp *data = dev_get_drvdata(dev);
133 /* Show each sensor label */
134 return data->ops.show_label(dev, devattr, buf);
137 static ssize_t show_input(struct device *dev,
138 struct device_attribute *devattr, char *buf)
141 struct rockchip_temp *data = dev_get_drvdata(dev);
142 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
143 u8 tsadc_addr = data->tsadc_addr[attr->index];
145 temp = data->ops.read_sensor(tsadc_addr);
147 return sprintf(buf, "%d\n", temp);
150 /* Set functions (RW nodes) */
151 static ssize_t set_min(struct device *dev, struct device_attribute *devattr,
152 const char *buf, size_t count)
155 struct rockchip_temp *data = dev_get_drvdata(dev);
156 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
157 int res = kstrtol(buf, 10, &val);
161 val = clamp_val(val, 0, DEFAULT_MAX_TEMP);
163 mutex_lock(&data->lock);
164 data->min[attr->index] = val;
165 threshold_updated(data);
166 mutex_unlock(&data->lock);
171 static ssize_t set_max(struct device *dev, struct device_attribute *devattr,
172 const char *buf, size_t count)
175 struct rockchip_temp *data = dev_get_drvdata(dev);
176 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
177 int res = kstrtol(buf, 10, &val);
181 val = clamp_val(val, 0, DEFAULT_MAX_TEMP);
183 mutex_lock(&data->lock);
184 data->max[attr->index] = val;
185 threshold_updated(data);
186 mutex_unlock(&data->lock);
191 static ssize_t set_max_hyst(struct device *dev,
192 struct device_attribute *devattr,
193 const char *buf, size_t count)
196 struct rockchip_temp *data = dev_get_drvdata(dev);
197 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
198 int res = kstrtoul(buf, 10, &val);
202 val = clamp_val(val, 0, DEFAULT_MAX_TEMP);
204 mutex_lock(&data->lock);
205 data->max_hyst[attr->index] = val;
206 threshold_updated(data);
207 mutex_unlock(&data->lock);
212 /* Show functions (RO nodes) */
213 static ssize_t show_min(struct device *dev,
214 struct device_attribute *devattr, char *buf)
216 struct rockchip_temp *data = dev_get_drvdata(dev);
217 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
219 return sprintf(buf, "%ld\n", data->min[attr->index]);
222 static ssize_t show_max(struct device *dev,
223 struct device_attribute *devattr, char *buf)
225 struct rockchip_temp *data = dev_get_drvdata(dev);
226 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
228 return sprintf(buf, "%ld\n", data->max[attr->index]);
231 static ssize_t show_max_hyst(struct device *dev,
232 struct device_attribute *devattr, char *buf)
234 struct rockchip_temp *data = dev_get_drvdata(dev);
235 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
237 return sprintf(buf, "%ld\n", data->max_hyst[attr->index]);
240 static ssize_t show_min_alarm(struct device *dev,
241 struct device_attribute *devattr, char *buf)
243 struct rockchip_temp *data = dev_get_drvdata(dev);
244 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
246 return sprintf(buf, "%d\n", data->min_alarm[attr->index]);
249 static ssize_t show_max_alarm(struct device *dev,
250 struct device_attribute *devattr, char *buf)
252 struct rockchip_temp *data = dev_get_drvdata(dev);
253 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
255 return sprintf(buf, "%d\n", data->max_alarm[attr->index]);
258 static umode_t rockchip_attrs_visible(struct kobject *kobj,
259 struct attribute *attr, int n)
261 struct device *dev = container_of(kobj, struct device, kobj);
262 struct rockchip_temp *data = dev_get_drvdata(dev);
264 if (data->ops.is_visible)
265 return data->ops.is_visible(attr, n);
270 /* Chip name, required by hwmon */
271 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
273 /* GPADC - SENSOR0 */
274 static SENSOR_DEVICE_ATTR(temp0_label, S_IRUGO, show_label, NULL, 0);
275 static SENSOR_DEVICE_ATTR(temp0_input, S_IRUGO, show_input, NULL, 0);
276 static SENSOR_DEVICE_ATTR(temp0_min, S_IWUSR | S_IRUGO, show_min, set_min, 0);
277 static SENSOR_DEVICE_ATTR(temp0_max, S_IWUSR | S_IRUGO, show_max, set_max, 0);
278 static SENSOR_DEVICE_ATTR(temp0_max_hyst, S_IWUSR | S_IRUGO,
279 show_max_hyst, set_max_hyst, 0);
280 static SENSOR_DEVICE_ATTR(temp0_min_alarm, S_IRUGO, show_min_alarm, NULL, 0);
281 static SENSOR_DEVICE_ATTR(temp0_max_alarm, S_IRUGO, show_max_alarm, NULL, 0);
283 /* GPADC - SENSOR1 */
284 static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_label, NULL, 1);
285 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 1);
286 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_min, set_min, 1);
287 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_max, set_max, 1);
288 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
289 show_max_hyst, set_max_hyst, 1);
290 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_min_alarm, NULL, 1);
291 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_max_alarm, NULL, 1);
293 /* GPADC - SENSOR2 */
294 static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_label, NULL, 2);
295 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2);
296 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min, 2);
297 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max, 2);
298 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IWUSR | S_IRUGO,
299 show_max_hyst, set_max_hyst, 2);
300 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_min_alarm, NULL, 2);
301 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_max_alarm, NULL, 2);
303 /* GPADC - SENSOR3 */
304 static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_label, NULL, 3);
305 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 3);
306 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min, 3);
307 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max, 3);
308 static SENSOR_DEVICE_ATTR(temp3_max_hyst, S_IWUSR | S_IRUGO,
309 show_max_hyst, set_max_hyst, 3);
310 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_min_alarm, NULL, 3);
311 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_max_alarm, NULL, 3);
314 struct attribute *rockchip_temp_attributes[] = {
315 &sensor_dev_attr_name.dev_attr.attr,
317 &sensor_dev_attr_temp0_label.dev_attr.attr,
318 &sensor_dev_attr_temp0_input.dev_attr.attr,
319 &sensor_dev_attr_temp0_min.dev_attr.attr,
320 &sensor_dev_attr_temp0_max.dev_attr.attr,
321 &sensor_dev_attr_temp0_max_hyst.dev_attr.attr,
322 &sensor_dev_attr_temp0_min_alarm.dev_attr.attr,
323 &sensor_dev_attr_temp0_max_alarm.dev_attr.attr,
325 &sensor_dev_attr_temp1_label.dev_attr.attr,
326 &sensor_dev_attr_temp1_input.dev_attr.attr,
327 &sensor_dev_attr_temp1_min.dev_attr.attr,
328 &sensor_dev_attr_temp1_max.dev_attr.attr,
329 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
330 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
331 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
333 &sensor_dev_attr_temp2_label.dev_attr.attr,
334 &sensor_dev_attr_temp2_input.dev_attr.attr,
335 &sensor_dev_attr_temp2_min.dev_attr.attr,
336 &sensor_dev_attr_temp2_max.dev_attr.attr,
337 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
338 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
339 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
341 &sensor_dev_attr_temp3_label.dev_attr.attr,
342 &sensor_dev_attr_temp3_input.dev_attr.attr,
343 &sensor_dev_attr_temp3_min.dev_attr.attr,
344 &sensor_dev_attr_temp3_max.dev_attr.attr,
345 &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
346 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
347 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
353 static const struct attribute_group rockchip_temp_group = {
354 .attrs = rockchip_temp_attributes,
355 .is_visible = rockchip_attrs_visible,
358 static int rockchip_temp_probe(struct platform_device *pdev)
360 struct rockchip_temp *data;
362 printk("%s,line=%d\n", __func__,__LINE__);
364 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
368 mutex_init(&data->lock);
370 /* Chip specific initialization */
371 err = rockchip_hwmon_init(data);
372 if (err < 0 || !data->ops.read_sensor || !data->ops.show_name ||
373 !data->ops.show_label)
376 INIT_DEFERRABLE_WORK(&data->work, tsadc_monitor);
377 platform_set_drvdata(pdev, data);
379 err = sysfs_create_group(&pdev->dev.kobj, &rockchip_temp_group);
381 dev_err(&pdev->dev, "Create sysfs group failed (%d)\n", err);
384 data->hwmon_dev = hwmon_device_register(&pdev->dev);
385 if (IS_ERR(data->hwmon_dev)) {
386 err = PTR_ERR(data->hwmon_dev);
387 dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
388 goto exit_sysfs_group;
393 sysfs_remove_group(&pdev->dev.kobj, &rockchip_temp_group);
397 static int rockchip_temp_remove(struct platform_device *pdev)
399 struct rockchip_temp *data = platform_get_drvdata(pdev);
401 cancel_delayed_work_sync(&data->work);
402 hwmon_device_unregister(data->hwmon_dev);
403 sysfs_remove_group(&pdev->dev.kobj, &rockchip_temp_group);
408 static int rockchip_temp_suspend(struct platform_device *pdev,
411 struct rockchip_temp *data = platform_get_drvdata(pdev);
413 if (data->work_active)
414 cancel_delayed_work_sync(&data->work);
419 static int rockchip_temp_resume(struct platform_device *pdev)
421 struct rockchip_temp *data = platform_get_drvdata(pdev);
423 if (data->work_active)
424 schedule_monitor(data);
430 static const struct of_device_id rockchip_temp_match[] = {
431 { .compatible = "rockchip,tsadc" },
436 static struct platform_driver rockchip_temp_driver = {
438 .owner = THIS_MODULE,
440 .of_match_table = of_match_ptr(rockchip_temp_match),
442 .suspend = rockchip_temp_suspend,
443 .resume = rockchip_temp_resume,
444 .probe = rockchip_temp_probe,
445 .remove = rockchip_temp_remove,
448 module_platform_driver(rockchip_temp_driver);
450 MODULE_AUTHOR("<rockchip>");
451 MODULE_DESCRIPTION("rockchip temperature driver");
452 MODULE_LICENSE("GPL");