1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * int340x_thermal_zone.c 4 * Copyright (c) 2015, Intel Corporation. 5 */ 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/init.h> 9 #include <linux/acpi.h> 10 #include <linux/thermal.h> 11 #include <linux/units.h> 12 #include "int340x_thermal_zone.h" 13 14 static int int340x_thermal_get_zone_temp(struct thermal_zone_device *zone, 15 int *temp) 16 { 17 struct int34x_thermal_zone *d = thermal_zone_device_priv(zone); 18 unsigned long long tmp; 19 acpi_status status; 20 21 status = acpi_evaluate_integer(d->adev->handle, "_TMP", NULL, &tmp); 22 if (ACPI_FAILURE(status)) 23 return -EIO; 24 25 if (d->lpat_table) { 26 int conv_temp; 27 28 conv_temp = acpi_lpat_raw_to_temp(d->lpat_table, (int)tmp); 29 if (conv_temp < 0) 30 return conv_temp; 31 32 *temp = conv_temp * 10; 33 } else { 34 /* _TMP returns the temperature in tenths of degrees Kelvin */ 35 *temp = deci_kelvin_to_millicelsius(tmp); 36 } 37 38 return 0; 39 } 40 41 static int int340x_thermal_set_trip_temp(struct thermal_zone_device *zone, 42 const struct thermal_trip *trip, int temp) 43 { 44 struct int34x_thermal_zone *d = thermal_zone_device_priv(zone); 45 unsigned int trip_index = THERMAL_TRIP_PRIV_TO_INT(trip->priv); 46 char name[] = {'P', 'A', 'T', '0' + trip_index, '\0'}; 47 acpi_status status; 48 49 if (trip_index > 9) 50 return -EINVAL; 51 52 status = acpi_execute_simple_method(d->adev->handle, name, 53 millicelsius_to_deci_kelvin(temp)); 54 if (ACPI_FAILURE(status)) 55 return -EIO; 56 57 return 0; 58 } 59 60 static void int340x_thermal_critical(struct thermal_zone_device *zone) 61 { 62 dev_dbg(thermal_zone_device(zone), "%s: critical temperature reached\n", 63 thermal_zone_device_type(zone)); 64 } 65 66 static int int340x_thermal_read_trips(struct acpi_device *zone_adev, 67 struct thermal_trip *zone_trips, 68 int trip_cnt) 69 { 70 int i, ret; 71 72 ret = thermal_acpi_critical_trip_temp(zone_adev, 73 &zone_trips[trip_cnt].temperature); 74 if (!ret) { 75 zone_trips[trip_cnt].type = THERMAL_TRIP_CRITICAL; 76 trip_cnt++; 77 } 78 79 ret = thermal_acpi_hot_trip_temp(zone_adev, 80 &zone_trips[trip_cnt].temperature); 81 if (!ret) { 82 zone_trips[trip_cnt].type = THERMAL_TRIP_HOT; 83 trip_cnt++; 84 } 85 86 ret = thermal_acpi_passive_trip_temp(zone_adev, 87 &zone_trips[trip_cnt].temperature); 88 if (!ret) { 89 zone_trips[trip_cnt].type = THERMAL_TRIP_PASSIVE; 90 trip_cnt++; 91 } 92 93 for (i = 0; i < INT340X_THERMAL_MAX_ACT_TRIP_COUNT; i++) { 94 ret = thermal_acpi_active_trip_temp(zone_adev, i, 95 &zone_trips[trip_cnt].temperature); 96 if (ret) 97 break; 98 99 zone_trips[trip_cnt].type = THERMAL_TRIP_ACTIVE; 100 zone_trips[trip_cnt].priv = THERMAL_INT_TO_TRIP_PRIV(i); 101 trip_cnt++; 102 } 103 104 return trip_cnt; 105 } 106 107 static struct thermal_zone_params int340x_thermal_params = { 108 .governor_name = "user_space", 109 .no_hwmon = true, 110 }; 111 112 struct int34x_thermal_zone *int340x_thermal_zone_add(struct acpi_device *adev, 113 int (*get_temp) (struct thermal_zone_device *, int *)) 114 { 115 const struct thermal_zone_device_ops zone_ops = { 116 .set_trip_temp = int340x_thermal_set_trip_temp, 117 .critical = int340x_thermal_critical, 118 .get_temp = get_temp ? get_temp : int340x_thermal_get_zone_temp, 119 }; 120 struct int34x_thermal_zone *int34x_zone; 121 struct thermal_trip *zone_trips; 122 unsigned long long trip_cnt = 0; 123 unsigned long long hyst; 124 acpi_status status; 125 int i, ret; 126 127 int34x_zone = kzalloc(sizeof(*int34x_zone), GFP_KERNEL); 128 if (!int34x_zone) 129 return ERR_PTR(-ENOMEM); 130 131 int34x_zone->adev = adev; 132 133 status = acpi_evaluate_integer(adev->handle, "PATC", NULL, &trip_cnt); 134 if (ACPI_SUCCESS(status)) 135 int34x_zone->aux_trip_nr = trip_cnt; 136 137 zone_trips = kzalloc(sizeof(*zone_trips) * (trip_cnt + INT340X_THERMAL_MAX_TRIP_COUNT), 138 GFP_KERNEL); 139 if (!zone_trips) { 140 ret = -ENOMEM; 141 goto err_trips_alloc; 142 } 143 144 for (i = 0; i < trip_cnt; i++) { 145 zone_trips[i].type = THERMAL_TRIP_PASSIVE; 146 zone_trips[i].temperature = THERMAL_TEMP_INVALID; 147 zone_trips[i].flags |= THERMAL_TRIP_FLAG_RW_TEMP; 148 zone_trips[i].priv = THERMAL_INT_TO_TRIP_PRIV(i); 149 } 150 151 trip_cnt = int340x_thermal_read_trips(adev, zone_trips, trip_cnt); 152 153 status = acpi_evaluate_integer(adev->handle, "GTSH", NULL, &hyst); 154 if (ACPI_SUCCESS(status)) 155 hyst *= 100; 156 else 157 hyst = 0; 158 159 for (i = 0; i < trip_cnt; ++i) 160 zone_trips[i].hysteresis = hyst; 161 162 int34x_zone->lpat_table = acpi_lpat_get_conversion_table(adev->handle); 163 164 int34x_zone->zone = thermal_zone_device_register_with_trips( 165 acpi_device_bid(adev), 166 zone_trips, trip_cnt, 167 int34x_zone, 168 &zone_ops, 169 &int340x_thermal_params, 170 0, 0); 171 kfree(zone_trips); 172 173 if (IS_ERR(int34x_zone->zone)) { 174 ret = PTR_ERR(int34x_zone->zone); 175 goto err_thermal_zone; 176 } 177 ret = thermal_zone_device_enable(int34x_zone->zone); 178 if (ret) 179 goto err_enable; 180 181 return int34x_zone; 182 183 err_enable: 184 thermal_zone_device_unregister(int34x_zone->zone); 185 err_thermal_zone: 186 acpi_lpat_free_conversion_table(int34x_zone->lpat_table); 187 err_trips_alloc: 188 kfree(int34x_zone); 189 return ERR_PTR(ret); 190 } 191 EXPORT_SYMBOL_GPL(int340x_thermal_zone_add); 192 193 void int340x_thermal_zone_remove(struct int34x_thermal_zone *int34x_zone) 194 { 195 thermal_zone_device_unregister(int34x_zone->zone); 196 acpi_lpat_free_conversion_table(int34x_zone->lpat_table); 197 kfree(int34x_zone); 198 } 199 EXPORT_SYMBOL_GPL(int340x_thermal_zone_remove); 200 201 static int int340x_update_one_trip(struct thermal_trip *trip, void *arg) 202 { 203 struct int34x_thermal_zone *int34x_zone = arg; 204 struct acpi_device *zone_adev = int34x_zone->adev; 205 int temp, err; 206 207 switch (trip->type) { 208 case THERMAL_TRIP_CRITICAL: 209 err = thermal_acpi_critical_trip_temp(zone_adev, &temp); 210 break; 211 case THERMAL_TRIP_HOT: 212 err = thermal_acpi_hot_trip_temp(zone_adev, &temp); 213 break; 214 case THERMAL_TRIP_PASSIVE: 215 err = thermal_acpi_passive_trip_temp(zone_adev, &temp); 216 break; 217 case THERMAL_TRIP_ACTIVE: 218 err = thermal_acpi_active_trip_temp(zone_adev, 219 THERMAL_TRIP_PRIV_TO_INT(trip->priv), 220 &temp); 221 break; 222 default: 223 err = -ENODEV; 224 } 225 if (err) 226 temp = THERMAL_TEMP_INVALID; 227 228 thermal_zone_set_trip_temp(int34x_zone->zone, trip, temp); 229 230 return 0; 231 } 232 233 void int340x_thermal_update_trips(struct int34x_thermal_zone *int34x_zone) 234 { 235 thermal_zone_for_each_trip(int34x_zone->zone, int340x_update_one_trip, 236 int34x_zone); 237 } 238 EXPORT_SYMBOL_GPL(int340x_thermal_update_trips); 239 240 MODULE_AUTHOR("Aaron Lu <aaron.lu@intel.com>"); 241 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>"); 242 MODULE_DESCRIPTION("Intel INT340x common thermal zone handler"); 243 MODULE_LICENSE("GPL v2"); 244