drivers/thermal/tegra/tegra-bpmp-thermal.c

   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 void 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
 310 static const struct of_device_id tegra_bpmp_thermal_of_match[] = {
 311         { .compatible = "nvidia,tegra186-bpmp-thermal" },
 312         { },
 313 };
 314 MODULE_DEVICE_TABLE(of, tegra_bpmp_thermal_of_match);
 315
 316 static struct platform_driver tegra_bpmp_thermal_driver = {
 317         .probe = tegra_bpmp_thermal_probe,
 318         .remove_new = tegra_bpmp_thermal_remove,
 319         .driver = {
 320                 .name = "tegra-bpmp-thermal",
 321                 .of_match_table = tegra_bpmp_thermal_of_match,
 322         },
 323 };
 324 module_platform_driver(tegra_bpmp_thermal_driver);
 325
 326 MODULE_AUTHOR("Mikko Perttunen <mperttunen@nvidia.com>");
 327 MODULE_DESCRIPTION("NVIDIA Tegra BPMP thermal sensor driver");
 328 MODULE_LICENSE("GPL v2");