1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. 4 * 5 * Author: 6 * Mikko Perttunen <mperttunen@nvidia.com> 7 * Aapo Vienamo <avienamo@nvidia.com> 8 */ 9 10 #include <linux/err.h> 11 #include <linux/module.h> 12 #include <linux/platform_device.h> 13 #include <linux/thermal.h> 14 #include <linux/workqueue.h> 15 16 #include <soc/tegra/bpmp.h> 17 #include <soc/tegra/bpmp-abi.h> 18 19 struct tegra_bpmp_thermal_zone { 20 struct tegra_bpmp_thermal *tegra; 21 struct thermal_zone_device *tzd; 22 struct work_struct tz_device_update_work; 23 unsigned int idx; 24 }; 25 26 struct tegra_bpmp_thermal { 27 struct device *dev; 28 struct tegra_bpmp *bpmp; 29 unsigned int num_zones; 30 struct tegra_bpmp_thermal_zone **zones; 31 }; 32 33 static int __tegra_bpmp_thermal_get_temp(struct tegra_bpmp_thermal_zone *zone, 34 int *out_temp) 35 { 36 struct mrq_thermal_host_to_bpmp_request req; 37 union mrq_thermal_bpmp_to_host_response reply; 38 struct tegra_bpmp_message msg; 39 int err; 40 41 memset(&req, 0, sizeof(req)); 42 req.type = CMD_THERMAL_GET_TEMP; 43 req.get_temp.zone = zone->idx; 44 45 memset(&msg, 0, sizeof(msg)); 46 msg.mrq = MRQ_THERMAL; 47 msg.tx.data = &req; 48 msg.tx.size = sizeof(req); 49 msg.rx.data = &reply; 50 msg.rx.size = sizeof(reply); 51 52 err = tegra_bpmp_transfer(zone->tegra->bpmp, &msg); 53 if (err) 54 return err; 55 if (msg.rx.ret == -BPMP_EFAULT) 56 return -EAGAIN; 57 if (msg.rx.ret) 58 return -EINVAL; 59 60 *out_temp = reply.get_temp.temp; 61 62 return 0; 63 } 64 65 static int tegra_bpmp_thermal_get_temp(struct thermal_zone_device *tz, int *out_temp) 66 { 67 struct tegra_bpmp_thermal_zone *zone = thermal_zone_device_priv(tz); 68 69 return __tegra_bpmp_thermal_get_temp(zone, out_temp); 70 } 71 72 static int tegra_bpmp_thermal_set_trips(struct thermal_zone_device *tz, int low, int high) 73 { 74 struct tegra_bpmp_thermal_zone *zone = thermal_zone_device_priv(tz); 75 struct mrq_thermal_host_to_bpmp_request req; 76 struct tegra_bpmp_message msg; 77 int err; 78 79 memset(&req, 0, sizeof(req)); 80 req.type = CMD_THERMAL_SET_TRIP; 81 req.set_trip.zone = zone->idx; 82 req.set_trip.enabled = true; 83 req.set_trip.low = low; 84 req.set_trip.high = high; 85 86 memset(&msg, 0, sizeof(msg)); 87 msg.mrq = MRQ_THERMAL; 88 msg.tx.data = &req; 89 msg.tx.size = sizeof(req); 90 91 err = tegra_bpmp_transfer(zone->tegra->bpmp, &msg); 92 if (err) 93 return err; 94 if (msg.rx.ret) 95 return -EINVAL; 96 97 return 0; 98 } 99 100 static void tz_device_update_work_fn(struct work_struct *work) 101 { 102 struct tegra_bpmp_thermal_zone *zone; 103 104 zone = container_of(work, struct tegra_bpmp_thermal_zone, 105 tz_device_update_work); 106 107 thermal_zone_device_update(zone->tzd, THERMAL_TRIP_VIOLATED); 108 } 109 110 static void bpmp_mrq_thermal(unsigned int mrq, struct tegra_bpmp_channel *ch, 111 void *data) 112 { 113 struct mrq_thermal_bpmp_to_host_request req; 114 struct tegra_bpmp_thermal *tegra = data; 115 size_t offset; 116 int i; 117 118 offset = offsetof(struct tegra_bpmp_mb_data, data); 119 iosys_map_memcpy_from(&req, &ch->ib, offset, sizeof(req)); 120 121 if (req.type != CMD_THERMAL_HOST_TRIP_REACHED) { 122 dev_err(tegra->dev, "%s: invalid request type: %d\n", __func__, req.type); 123 tegra_bpmp_mrq_return(ch, -EINVAL, NULL, 0); 124 return; 125 } 126 127 for (i = 0; i < tegra->num_zones; ++i) { 128 if (tegra->zones[i]->idx != req.host_trip_reached.zone) 129 continue; 130 131 schedule_work(&tegra->zones[i]->tz_device_update_work); 132 tegra_bpmp_mrq_return(ch, 0, NULL, 0); 133 return; 134 } 135 136 dev_err(tegra->dev, "%s: invalid thermal zone: %d\n", __func__, 137 req.host_trip_reached.zone); 138 tegra_bpmp_mrq_return(ch, -EINVAL, NULL, 0); 139 } 140 141 static int tegra_bpmp_thermal_get_num_zones(struct tegra_bpmp *bpmp, 142 int *num_zones) 143 { 144 struct mrq_thermal_host_to_bpmp_request req; 145 union mrq_thermal_bpmp_to_host_response reply; 146 struct tegra_bpmp_message msg; 147 int err; 148 149 memset(&req, 0, sizeof(req)); 150 req.type = CMD_THERMAL_GET_NUM_ZONES; 151 152 memset(&msg, 0, sizeof(msg)); 153 msg.mrq = MRQ_THERMAL; 154 msg.tx.data = &req; 155 msg.tx.size = sizeof(req); 156 msg.rx.data = &reply; 157 msg.rx.size = sizeof(reply); 158 159 err = tegra_bpmp_transfer(bpmp, &msg); 160 if (err) 161 return err; 162 if (msg.rx.ret) 163 return -EINVAL; 164 165 *num_zones = reply.get_num_zones.num; 166 167 return 0; 168 } 169 170 static int tegra_bpmp_thermal_trips_supported(struct tegra_bpmp *bpmp, bool *supported) 171 { 172 struct mrq_thermal_host_to_bpmp_request req; 173 union mrq_thermal_bpmp_to_host_response reply; 174 struct tegra_bpmp_message msg; 175 int err; 176 177 memset(&req, 0, sizeof(req)); 178 req.type = CMD_THERMAL_QUERY_ABI; 179 req.query_abi.type = CMD_THERMAL_SET_TRIP; 180 181 memset(&msg, 0, sizeof(msg)); 182 msg.mrq = MRQ_THERMAL; 183 msg.tx.data = &req; 184 msg.tx.size = sizeof(req); 185 msg.rx.data = &reply; 186 msg.rx.size = sizeof(reply); 187 188 err = tegra_bpmp_transfer(bpmp, &msg); 189 if (err) 190 return err; 191 192 if (msg.rx.ret == 0) { 193 *supported = true; 194 return 0; 195 } else if (msg.rx.ret == -BPMP_ENODEV) { 196 *supported = false; 197 return 0; 198 } else { 199 return -EINVAL; 200 } 201 } 202 203 static const struct thermal_zone_device_ops tegra_bpmp_of_thermal_ops = { 204 .get_temp = tegra_bpmp_thermal_get_temp, 205 .set_trips = tegra_bpmp_thermal_set_trips, 206 }; 207 208 static const struct thermal_zone_device_ops tegra_bpmp_of_thermal_ops_notrips = { 209 .get_temp = tegra_bpmp_thermal_get_temp, 210 }; 211 212 static int tegra_bpmp_thermal_probe(struct platform_device *pdev) 213 { 214 struct tegra_bpmp *bpmp = dev_get_drvdata(pdev->dev.parent); 215 const struct thermal_zone_device_ops *thermal_ops; 216 struct tegra_bpmp_thermal *tegra; 217 struct thermal_zone_device *tzd; 218 unsigned int i, max_num_zones; 219 bool supported; 220 int err; 221 222 err = tegra_bpmp_thermal_trips_supported(bpmp, &supported); 223 if (err) { 224 dev_err(&pdev->dev, "failed to determine if trip points are supported\n"); 225 return err; 226 } 227 228 if (supported) 229 thermal_ops = &tegra_bpmp_of_thermal_ops; 230 else 231 thermal_ops = &tegra_bpmp_of_thermal_ops_notrips; 232 233 tegra = devm_kzalloc(&pdev->dev, sizeof(*tegra), GFP_KERNEL); 234 if (!tegra) 235 return -ENOMEM; 236 237 tegra->dev = &pdev->dev; 238 tegra->bpmp = bpmp; 239 240 err = tegra_bpmp_thermal_get_num_zones(bpmp, &max_num_zones); 241 if (err) { 242 dev_err(&pdev->dev, "failed to get the number of zones: %d\n", 243 err); 244 return err; 245 } 246 247 tegra->zones = devm_kcalloc(&pdev->dev, max_num_zones, 248 sizeof(*tegra->zones), GFP_KERNEL); 249 if (!tegra->zones) 250 return -ENOMEM; 251 252 for (i = 0; i < max_num_zones; ++i) { 253 struct tegra_bpmp_thermal_zone *zone; 254 int temp; 255 256 zone = devm_kzalloc(&pdev->dev, sizeof(*zone), GFP_KERNEL); 257 if (!zone) 258 return -ENOMEM; 259 260 zone->idx = i; 261 zone->tegra = tegra; 262 263 err = __tegra_bpmp_thermal_get_temp(zone, &temp); 264 265 /* 266 * Sensors in powergated domains may temporarily fail to be read 267 * (-EAGAIN), but will become accessible when the domain is powered on. 268 */ 269 if (err < 0 && err != -EAGAIN) { 270 devm_kfree(&pdev->dev, zone); 271 continue; 272 } 273 274 tzd = devm_thermal_of_zone_register( 275 &pdev->dev, i, zone, thermal_ops); 276 if (IS_ERR(tzd)) { 277 if (PTR_ERR(tzd) == -EPROBE_DEFER) 278 return -EPROBE_DEFER; 279 devm_kfree(&pdev->dev, zone); 280 continue; 281 } 282 283 zone->tzd = tzd; 284 INIT_WORK(&zone->tz_device_update_work, 285 tz_device_update_work_fn); 286 287 tegra->zones[tegra->num_zones++] = zone; 288 } 289 290 err = tegra_bpmp_request_mrq(bpmp, MRQ_THERMAL, bpmp_mrq_thermal, 291 tegra); 292 if (err) { 293 dev_err(&pdev->dev, "failed to register mrq handler: %d\n", 294 err); 295 return err; 296 } 297 298 platform_set_drvdata(pdev, tegra); 299 300 return 0; 301 } 302 303 static int tegra_bpmp_thermal_remove(struct platform_device *pdev) 304 { 305 struct tegra_bpmp_thermal *tegra = platform_get_drvdata(pdev); 306 307 tegra_bpmp_free_mrq(tegra->bpmp, MRQ_THERMAL, tegra); 308 309 return 0; 310 } 311 312 static const struct of_device_id tegra_bpmp_thermal_of_match[] = { 313 { .compatible = "nvidia,tegra186-bpmp-thermal" }, 314 { }, 315 }; 316 MODULE_DEVICE_TABLE(of, tegra_bpmp_thermal_of_match); 317 318 static struct platform_driver tegra_bpmp_thermal_driver = { 319 .probe = tegra_bpmp_thermal_probe, 320 .remove = tegra_bpmp_thermal_remove, 321 .driver = { 322 .name = "tegra-bpmp-thermal", 323 .of_match_table = tegra_bpmp_thermal_of_match, 324 }, 325 }; 326 module_platform_driver(tegra_bpmp_thermal_driver); 327 328 MODULE_AUTHOR("Mikko Perttunen <mperttunen@nvidia.com>"); 329 MODULE_DESCRIPTION("NVIDIA Tegra BPMP thermal sensor driver"); 330 MODULE_LICENSE("GPL v2"); 331