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(void *data, int *out_temp)
  34 {
  35         struct tegra_bpmp_thermal_zone *zone = data;
  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
  56         *out_temp = reply.get_temp.temp;
  57
  58         return 0;
  59 }
  60
  61 static int tegra_bpmp_thermal_set_trips(void *data, int low, int high)
  62 {
  63         struct tegra_bpmp_thermal_zone *zone = data;
  64         struct mrq_thermal_host_to_bpmp_request req;
  65         struct tegra_bpmp_message msg;
  66
  67         memset(&req, 0, sizeof(req));
  68         req.type = CMD_THERMAL_SET_TRIP;
  69         req.set_trip.zone = zone->idx;
  70         req.set_trip.enabled = true;
  71         req.set_trip.low = low;
  72         req.set_trip.high = high;
  73
  74         memset(&msg, 0, sizeof(msg));
  75         msg.mrq = MRQ_THERMAL;
  76         msg.tx.data = &req;
  77         msg.tx.size = sizeof(req);
  78
  79         return tegra_bpmp_transfer(zone->tegra->bpmp, &msg);
  80 }
  81
  82 static void tz_device_update_work_fn(struct work_struct *work)
  83 {
  84         struct tegra_bpmp_thermal_zone *zone;
  85
  86         zone = container_of(work, struct tegra_bpmp_thermal_zone,
  87                             tz_device_update_work);
  88
  89         thermal_zone_device_update(zone->tzd, THERMAL_TRIP_VIOLATED);
  90 }
  91
  92 static void bpmp_mrq_thermal(unsigned int mrq, struct tegra_bpmp_channel *ch,
  93                              void *data)
  94 {
  95         struct mrq_thermal_bpmp_to_host_request *req;
  96         struct tegra_bpmp_thermal *tegra = data;
  97         int i;
  98
  99         req = (struct mrq_thermal_bpmp_to_host_request *)ch->ib->data;
 100
 101         if (req->type != CMD_THERMAL_HOST_TRIP_REACHED) {
 102                 dev_err(tegra->dev, "%s: invalid request type: %d\n",
 103                         __func__, req->type);
 104                 tegra_bpmp_mrq_return(ch, -EINVAL, NULL, 0);
 105                 return;
 106         }
 107
 108         for (i = 0; i < tegra->num_zones; ++i) {
 109                 if (tegra->zones[i]->idx != req->host_trip_reached.zone)
 110                         continue;
 111
 112                 schedule_work(&tegra->zones[i]->tz_device_update_work);
 113                 tegra_bpmp_mrq_return(ch, 0, NULL, 0);
 114                 return;
 115         }
 116
 117         dev_err(tegra->dev, "%s: invalid thermal zone: %d\n", __func__,
 118                 req->host_trip_reached.zone);
 119         tegra_bpmp_mrq_return(ch, -EINVAL, NULL, 0);
 120 }
 121
 122 static int tegra_bpmp_thermal_get_num_zones(struct tegra_bpmp *bpmp,
 123                                             int *num_zones)
 124 {
 125         struct mrq_thermal_host_to_bpmp_request req;
 126         union mrq_thermal_bpmp_to_host_response reply;
 127         struct tegra_bpmp_message msg;
 128         int err;
 129
 130         memset(&req, 0, sizeof(req));
 131         req.type = CMD_THERMAL_GET_NUM_ZONES;
 132
 133         memset(&msg, 0, sizeof(msg));
 134         msg.mrq = MRQ_THERMAL;
 135         msg.tx.data = &req;
 136         msg.tx.size = sizeof(req);
 137         msg.rx.data = &reply;
 138         msg.rx.size = sizeof(reply);
 139
 140         err = tegra_bpmp_transfer(bpmp, &msg);
 141         if (err)
 142                 return err;
 143
 144         *num_zones = reply.get_num_zones.num;
 145
 146         return 0;
 147 }
 148
 149 static const struct thermal_zone_of_device_ops tegra_bpmp_of_thermal_ops = {
 150         .get_temp = tegra_bpmp_thermal_get_temp,
 151         .set_trips = tegra_bpmp_thermal_set_trips,
 152 };
 153
 154 static int tegra_bpmp_thermal_probe(struct platform_device *pdev)
 155 {
 156         struct tegra_bpmp *bpmp = dev_get_drvdata(pdev->dev.parent);
 157         struct tegra_bpmp_thermal *tegra;
 158         struct thermal_zone_device *tzd;
 159         unsigned int i, max_num_zones;
 160         int err;
 161
 162         tegra = devm_kzalloc(&pdev->dev, sizeof(*tegra), GFP_KERNEL);
 163         if (!tegra)
 164                 return -ENOMEM;
 165
 166         tegra->dev = &pdev->dev;
 167         tegra->bpmp = bpmp;
 168
 169         err = tegra_bpmp_thermal_get_num_zones(bpmp, &max_num_zones);
 170         if (err) {
 171                 dev_err(&pdev->dev, "failed to get the number of zones: %d\n",
 172                         err);
 173                 return err;
 174         }
 175
 176         tegra->zones = devm_kcalloc(&pdev->dev, max_num_zones,
 177                                     sizeof(*tegra->zones), GFP_KERNEL);
 178         if (!tegra->zones)
 179                 return -ENOMEM;
 180
 181         for (i = 0; i < max_num_zones; ++i) {
 182                 struct tegra_bpmp_thermal_zone *zone;
 183                 int temp;
 184
 185                 zone = devm_kzalloc(&pdev->dev, sizeof(*zone), GFP_KERNEL);
 186                 if (!zone)
 187                         return -ENOMEM;
 188
 189                 zone->idx = i;
 190                 zone->tegra = tegra;
 191
 192                 err = tegra_bpmp_thermal_get_temp(zone, &temp);
 193                 if (err < 0) {
 194                         devm_kfree(&pdev->dev, zone);
 195                         continue;
 196                 }
 197
 198                 tzd = devm_thermal_zone_of_sensor_register(
 199                         &pdev->dev, i, zone, &tegra_bpmp_of_thermal_ops);
 200                 if (IS_ERR(tzd)) {
 201                         if (PTR_ERR(tzd) == -EPROBE_DEFER)
 202                                 return -EPROBE_DEFER;
 203                         devm_kfree(&pdev->dev, zone);
 204                         continue;
 205                 }
 206
 207                 zone->tzd = tzd;
 208                 INIT_WORK(&zone->tz_device_update_work,
 209                           tz_device_update_work_fn);
 210
 211                 tegra->zones[tegra->num_zones++] = zone;
 212         }
 213
 214         err = tegra_bpmp_request_mrq(bpmp, MRQ_THERMAL, bpmp_mrq_thermal,
 215                                      tegra);
 216         if (err) {
 217                 dev_err(&pdev->dev, "failed to register mrq handler: %d\n",
 218                         err);
 219                 return err;
 220         }
 221
 222         platform_set_drvdata(pdev, tegra);
 223
 224         return 0;
 225 }
 226
 227 static int tegra_bpmp_thermal_remove(struct platform_device *pdev)
 228 {
 229         struct tegra_bpmp_thermal *tegra = platform_get_drvdata(pdev);
 230
 231         tegra_bpmp_free_mrq(tegra->bpmp, MRQ_THERMAL, tegra);
 232
 233         return 0;
 234 }
 235
 236 static const struct of_device_id tegra_bpmp_thermal_of_match[] = {
 237         { .compatible = "nvidia,tegra186-bpmp-thermal" },
 238         { },
 239 };
 240 MODULE_DEVICE_TABLE(of, tegra_bpmp_thermal_of_match);
 241
 242 static struct platform_driver tegra_bpmp_thermal_driver = {
 243         .probe = tegra_bpmp_thermal_probe,
 244         .remove = tegra_bpmp_thermal_remove,
 245         .driver = {
 246                 .name = "tegra-bpmp-thermal",
 247                 .of_match_table = tegra_bpmp_thermal_of_match,
 248         },
 249 };
 250 module_platform_driver(tegra_bpmp_thermal_driver);
 251
 252 MODULE_AUTHOR("Mikko Perttunen <mperttunen@nvidia.com>");
 253 MODULE_DESCRIPTION("NVIDIA Tegra BPMP thermal sensor driver");
 254 MODULE_LICENSE("GPL v2");