2 * thermal.c - sysfs interface of thermal devices
4 * Copyright (C) 2016 Eduardo Valentin <edubezval@gmail.com>
6 * Highly based on original thermal_core.c
7 * Copyright (C) 2008 Intel Corp
8 * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
9 * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2 of the License.
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18 #include <linux/sysfs.h>
19 #include <linux/device.h>
20 #include <linux/err.h>
21 #include <linux/slab.h>
22 #include <linux/string.h>
24 #include "thermal_core.h"
26 /* sys I/F for thermal zone */
29 type_show(struct device *dev, struct device_attribute *attr, char *buf)
31 struct thermal_zone_device *tz = to_thermal_zone(dev);
33 return sprintf(buf, "%s\n", tz->type);
37 temp_show(struct device *dev, struct device_attribute *attr, char *buf)
39 struct thermal_zone_device *tz = to_thermal_zone(dev);
42 ret = thermal_zone_get_temp(tz, &temperature);
47 return sprintf(buf, "%d\n", temperature);
51 mode_show(struct device *dev, struct device_attribute *attr, char *buf)
53 struct thermal_zone_device *tz = to_thermal_zone(dev);
54 enum thermal_device_mode mode;
57 if (!tz->ops->get_mode)
60 result = tz->ops->get_mode(tz, &mode);
64 return sprintf(buf, "%s\n", mode == THERMAL_DEVICE_ENABLED ? "enabled"
69 mode_store(struct device *dev, struct device_attribute *attr,
70 const char *buf, size_t count)
72 struct thermal_zone_device *tz = to_thermal_zone(dev);
75 if (!tz->ops->set_mode)
78 if (!strncmp(buf, "enabled", sizeof("enabled") - 1))
79 result = tz->ops->set_mode(tz, THERMAL_DEVICE_ENABLED);
80 else if (!strncmp(buf, "disabled", sizeof("disabled") - 1))
81 result = tz->ops->set_mode(tz, THERMAL_DEVICE_DISABLED);
92 trip_point_type_show(struct device *dev, struct device_attribute *attr,
95 struct thermal_zone_device *tz = to_thermal_zone(dev);
96 enum thermal_trip_type type;
99 if (!tz->ops->get_trip_type)
102 if (sscanf(attr->attr.name, "trip_point_%d_type", &trip) != 1)
105 result = tz->ops->get_trip_type(tz, trip, &type);
110 case THERMAL_TRIP_CRITICAL:
111 return sprintf(buf, "critical\n");
112 case THERMAL_TRIP_HOT:
113 return sprintf(buf, "hot\n");
114 case THERMAL_TRIP_PASSIVE:
115 return sprintf(buf, "passive\n");
116 case THERMAL_TRIP_ACTIVE:
117 return sprintf(buf, "active\n");
119 return sprintf(buf, "unknown\n");
124 trip_point_temp_store(struct device *dev, struct device_attribute *attr,
125 const char *buf, size_t count)
127 struct thermal_zone_device *tz = to_thermal_zone(dev);
131 if (!tz->ops->set_trip_temp)
134 if (sscanf(attr->attr.name, "trip_point_%d_temp", &trip) != 1)
137 if (kstrtoint(buf, 10, &temperature))
140 ret = tz->ops->set_trip_temp(tz, trip, temperature);
144 thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
150 trip_point_temp_show(struct device *dev, struct device_attribute *attr,
153 struct thermal_zone_device *tz = to_thermal_zone(dev);
157 if (!tz->ops->get_trip_temp)
160 if (sscanf(attr->attr.name, "trip_point_%d_temp", &trip) != 1)
163 ret = tz->ops->get_trip_temp(tz, trip, &temperature);
168 return sprintf(buf, "%d\n", temperature);
172 trip_point_hyst_store(struct device *dev, struct device_attribute *attr,
173 const char *buf, size_t count)
175 struct thermal_zone_device *tz = to_thermal_zone(dev);
179 if (!tz->ops->set_trip_hyst)
182 if (sscanf(attr->attr.name, "trip_point_%d_hyst", &trip) != 1)
185 if (kstrtoint(buf, 10, &temperature))
189 * We are not doing any check on the 'temperature' value
190 * here. The driver implementing 'set_trip_hyst' has to
193 ret = tz->ops->set_trip_hyst(tz, trip, temperature);
196 thermal_zone_set_trips(tz);
198 return ret ? ret : count;
202 trip_point_hyst_show(struct device *dev, struct device_attribute *attr,
205 struct thermal_zone_device *tz = to_thermal_zone(dev);
209 if (!tz->ops->get_trip_hyst)
212 if (sscanf(attr->attr.name, "trip_point_%d_hyst", &trip) != 1)
215 ret = tz->ops->get_trip_hyst(tz, trip, &temperature);
217 return ret ? ret : sprintf(buf, "%d\n", temperature);
221 passive_store(struct device *dev, struct device_attribute *attr,
222 const char *buf, size_t count)
224 struct thermal_zone_device *tz = to_thermal_zone(dev);
227 if (sscanf(buf, "%d\n", &state) != 1)
230 /* sanity check: values below 1000 millicelcius don't make sense
231 * and can cause the system to go into a thermal heart attack
233 if (state && state < 1000)
236 if (state && !tz->forced_passive) {
237 if (!tz->passive_delay)
238 tz->passive_delay = 1000;
239 thermal_zone_device_rebind_exception(tz, "Processor",
240 sizeof("Processor"));
241 } else if (!state && tz->forced_passive) {
242 tz->passive_delay = 0;
243 thermal_zone_device_unbind_exception(tz, "Processor",
244 sizeof("Processor"));
247 tz->forced_passive = state;
249 thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
255 passive_show(struct device *dev, struct device_attribute *attr,
258 struct thermal_zone_device *tz = to_thermal_zone(dev);
260 return sprintf(buf, "%d\n", tz->forced_passive);
264 policy_store(struct device *dev, struct device_attribute *attr,
265 const char *buf, size_t count)
267 struct thermal_zone_device *tz = to_thermal_zone(dev);
268 char name[THERMAL_NAME_LENGTH];
271 snprintf(name, sizeof(name), "%s", buf);
273 ret = thermal_zone_device_set_policy(tz, name);
281 policy_show(struct device *dev, struct device_attribute *devattr, char *buf)
283 struct thermal_zone_device *tz = to_thermal_zone(dev);
285 return sprintf(buf, "%s\n", tz->governor->name);
289 available_policies_show(struct device *dev, struct device_attribute *devattr,
292 return thermal_build_list_of_policies(buf);
296 emul_temp_store(struct device *dev, struct device_attribute *attr,
297 const char *buf, size_t count)
299 struct thermal_zone_device *tz = to_thermal_zone(dev);
303 if (kstrtoint(buf, 10, &temperature))
306 if (!tz->ops->set_emul_temp) {
307 mutex_lock(&tz->lock);
308 tz->emul_temperature = temperature;
309 mutex_unlock(&tz->lock);
311 ret = tz->ops->set_emul_temp(tz, temperature);
315 thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
317 return ret ? ret : count;
321 sustainable_power_show(struct device *dev, struct device_attribute *devattr,
324 struct thermal_zone_device *tz = to_thermal_zone(dev);
327 return sprintf(buf, "%u\n", tz->tzp->sustainable_power);
333 sustainable_power_store(struct device *dev, struct device_attribute *devattr,
334 const char *buf, size_t count)
336 struct thermal_zone_device *tz = to_thermal_zone(dev);
337 u32 sustainable_power;
342 if (kstrtou32(buf, 10, &sustainable_power))
345 tz->tzp->sustainable_power = sustainable_power;
350 #define create_s32_tzp_attr(name) \
352 name##_show(struct device *dev, struct device_attribute *devattr, \
355 struct thermal_zone_device *tz = to_thermal_zone(dev); \
358 return sprintf(buf, "%d\n", tz->tzp->name); \
364 name##_store(struct device *dev, struct device_attribute *devattr, \
365 const char *buf, size_t count) \
367 struct thermal_zone_device *tz = to_thermal_zone(dev); \
373 if (kstrtos32(buf, 10, &value)) \
376 tz->tzp->name = value; \
380 static DEVICE_ATTR(name, S_IWUSR | S_IRUGO, name##_show, name##_store)
382 create_s32_tzp_attr(k_po);
383 create_s32_tzp_attr(k_pu);
384 create_s32_tzp_attr(k_i);
385 create_s32_tzp_attr(k_d);
386 create_s32_tzp_attr(integral_cutoff);
387 create_s32_tzp_attr(slope);
388 create_s32_tzp_attr(offset);
389 #undef create_s32_tzp_attr
392 * These are thermal zone device attributes that will always be present.
393 * All the attributes created for tzp (create_s32_tzp_attr) also are always
394 * present on the sysfs interface.
396 static DEVICE_ATTR(type, 0444, type_show, NULL);
397 static DEVICE_ATTR(temp, 0444, temp_show, NULL);
398 static DEVICE_ATTR(emul_temp, S_IWUSR, NULL, emul_temp_store);
399 static DEVICE_ATTR(policy, S_IRUGO | S_IWUSR, policy_show, policy_store);
400 static DEVICE_ATTR(available_policies, S_IRUGO, available_policies_show, NULL);
401 static DEVICE_ATTR(sustainable_power, S_IWUSR | S_IRUGO, sustainable_power_show,
402 sustainable_power_store);
404 /* These thermal zone device attributes are created based on conditions */
405 static DEVICE_ATTR(mode, 0644, mode_show, mode_store);
406 static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, passive_store);
408 /* These attributes are unconditionally added to a thermal zone */
409 static struct attribute *thermal_zone_dev_attrs[] = {
412 #if (IS_ENABLED(CONFIG_THERMAL_EMULATION))
413 &dev_attr_emul_temp.attr,
415 &dev_attr_policy.attr,
416 &dev_attr_available_policies.attr,
417 &dev_attr_sustainable_power.attr,
422 &dev_attr_integral_cutoff.attr,
423 &dev_attr_slope.attr,
424 &dev_attr_offset.attr,
428 static struct attribute_group thermal_zone_attribute_group = {
429 .attrs = thermal_zone_dev_attrs,
432 /* We expose mode only if .get_mode is present */
433 static struct attribute *thermal_zone_mode_attrs[] = {
438 static umode_t thermal_zone_mode_is_visible(struct kobject *kobj,
439 struct attribute *attr,
442 struct device *dev = container_of(kobj, struct device, kobj);
443 struct thermal_zone_device *tz;
445 tz = container_of(dev, struct thermal_zone_device, device);
447 if (tz->ops->get_mode)
453 static struct attribute_group thermal_zone_mode_attribute_group = {
454 .attrs = thermal_zone_mode_attrs,
455 .is_visible = thermal_zone_mode_is_visible,
458 /* We expose passive only if passive trips are present */
459 static struct attribute *thermal_zone_passive_attrs[] = {
460 &dev_attr_passive.attr,
464 static umode_t thermal_zone_passive_is_visible(struct kobject *kobj,
465 struct attribute *attr,
468 struct device *dev = container_of(kobj, struct device, kobj);
469 struct thermal_zone_device *tz;
470 enum thermal_trip_type trip_type;
471 int count, passive = 0;
473 tz = container_of(dev, struct thermal_zone_device, device);
475 for (count = 0; count < tz->trips && !passive; count++) {
476 tz->ops->get_trip_type(tz, count, &trip_type);
478 if (trip_type == THERMAL_TRIP_PASSIVE)
488 static struct attribute_group thermal_zone_passive_attribute_group = {
489 .attrs = thermal_zone_passive_attrs,
490 .is_visible = thermal_zone_passive_is_visible,
493 static const struct attribute_group *thermal_zone_attribute_groups[] = {
494 &thermal_zone_attribute_group,
495 &thermal_zone_mode_attribute_group,
496 &thermal_zone_passive_attribute_group,
497 /* This is not NULL terminated as we create the group dynamically */
501 * create_trip_attrs() - create attributes for trip points
502 * @tz: the thermal zone device
503 * @mask: Writeable trip point bitmap.
505 * helper function to instantiate sysfs entries for every trip
506 * point and its properties of a struct thermal_zone_device.
508 * Return: 0 on success, the proper error value otherwise.
510 static int create_trip_attrs(struct thermal_zone_device *tz, int mask)
512 int size = sizeof(struct thermal_attr) * tz->trips;
513 struct attribute **attrs;
516 /* This function works only for zones with at least one trip */
520 tz->trip_type_attrs = kzalloc(size, GFP_KERNEL);
521 if (!tz->trip_type_attrs)
524 tz->trip_temp_attrs = kzalloc(size, GFP_KERNEL);
525 if (!tz->trip_temp_attrs) {
526 kfree(tz->trip_type_attrs);
530 if (tz->ops->get_trip_hyst) {
531 tz->trip_hyst_attrs = kzalloc(size, GFP_KERNEL);
532 if (!tz->trip_hyst_attrs) {
533 kfree(tz->trip_type_attrs);
534 kfree(tz->trip_temp_attrs);
539 attrs = kzalloc(sizeof(*attrs) * tz->trips * 3 + 1, GFP_KERNEL);
541 kfree(tz->trip_type_attrs);
542 kfree(tz->trip_temp_attrs);
543 if (tz->ops->get_trip_hyst)
544 kfree(tz->trip_hyst_attrs);
548 for (indx = 0; indx < tz->trips; indx++) {
549 /* create trip type attribute */
550 snprintf(tz->trip_type_attrs[indx].name, THERMAL_NAME_LENGTH,
551 "trip_point_%d_type", indx);
553 sysfs_attr_init(&tz->trip_type_attrs[indx].attr.attr);
554 tz->trip_type_attrs[indx].attr.attr.name =
555 tz->trip_type_attrs[indx].name;
556 tz->trip_type_attrs[indx].attr.attr.mode = S_IRUGO;
557 tz->trip_type_attrs[indx].attr.show = trip_point_type_show;
558 attrs[indx] = &tz->trip_type_attrs[indx].attr.attr;
560 /* create trip temp attribute */
561 snprintf(tz->trip_temp_attrs[indx].name, THERMAL_NAME_LENGTH,
562 "trip_point_%d_temp", indx);
564 sysfs_attr_init(&tz->trip_temp_attrs[indx].attr.attr);
565 tz->trip_temp_attrs[indx].attr.attr.name =
566 tz->trip_temp_attrs[indx].name;
567 tz->trip_temp_attrs[indx].attr.attr.mode = S_IRUGO;
568 tz->trip_temp_attrs[indx].attr.show = trip_point_temp_show;
569 if (IS_ENABLED(CONFIG_THERMAL_WRITABLE_TRIPS) &&
570 mask & (1 << indx)) {
571 tz->trip_temp_attrs[indx].attr.attr.mode |= S_IWUSR;
572 tz->trip_temp_attrs[indx].attr.store =
573 trip_point_temp_store;
575 attrs[indx + tz->trips] = &tz->trip_temp_attrs[indx].attr.attr;
577 /* create Optional trip hyst attribute */
578 if (!tz->ops->get_trip_hyst)
580 snprintf(tz->trip_hyst_attrs[indx].name, THERMAL_NAME_LENGTH,
581 "trip_point_%d_hyst", indx);
583 sysfs_attr_init(&tz->trip_hyst_attrs[indx].attr.attr);
584 tz->trip_hyst_attrs[indx].attr.attr.name =
585 tz->trip_hyst_attrs[indx].name;
586 tz->trip_hyst_attrs[indx].attr.attr.mode = S_IRUGO;
587 tz->trip_hyst_attrs[indx].attr.show = trip_point_hyst_show;
588 if (tz->ops->set_trip_hyst) {
589 tz->trip_hyst_attrs[indx].attr.attr.mode |= S_IWUSR;
590 tz->trip_hyst_attrs[indx].attr.store =
591 trip_point_hyst_store;
593 attrs[indx + tz->trips * 2] =
594 &tz->trip_hyst_attrs[indx].attr.attr;
596 attrs[tz->trips * 3] = NULL;
598 tz->trips_attribute_group.attrs = attrs;
603 int thermal_zone_create_device_groups(struct thermal_zone_device *tz,
606 const struct attribute_group **groups;
609 /* we need one extra for trips and the NULL to terminate the array */
610 size = ARRAY_SIZE(thermal_zone_attribute_groups) + 2;
611 /* This also takes care of API requirement to be NULL terminated */
612 groups = kcalloc(size, sizeof(*groups), GFP_KERNEL);
616 for (i = 0; i < size - 2; i++)
617 groups[i] = thermal_zone_attribute_groups[i];
620 result = create_trip_attrs(tz, mask);
627 groups[size - 2] = &tz->trips_attribute_group;
630 tz->device.groups = groups;