drivers/thermal/testing/zone.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2024, Intel Corporation
   4  *
   5  * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
   6  *
   7  * Thermal zone tempalates handling for thermal core testing.
   8  */
   9
  10 #define pr_fmt(fmt) "thermal-testing: " fmt
  11
  12 #include <linux/debugfs.h>
  13 #include <linux/idr.h>
  14 #include <linux/list.h>
  15 #include <linux/thermal.h>
  16 #include <linux/workqueue.h>
  17
  18 #include "thermal_testing.h"
  19
  20 #define TT_MAX_FILE_NAME_LENGTH         16
  21
  22 /**
  23  * struct tt_thermal_zone - Testing thermal zone template
  24  *
  25  * Represents a template of a thermal zone that can be used for registering
  26  * a test thermal zone with the thermal core.
  27  *
  28  * @list_node: Node in the list of all testing thermal zone templates.
  29  * @trips: List of trip point templates for this thermal zone template.
  30  * @d_tt_zone: Directory in debugfs representing this template.
  31  * @tz: Test thermal zone based on this template, if present.
  32  * @lock: Mutex for synchronizing changes of this template.
  33  * @ida: IDA for trip point IDs.
  34  * @id: The ID of this template for the debugfs interface.
  35  * @temp: Temperature value.
  36  * @tz_temp: Current thermal zone temperature (after registration).
  37  * @num_trips: Number of trip points in the @trips list.
  38  * @refcount: Reference counter for usage and removal synchronization.
  39  */
  40 struct tt_thermal_zone {
  41         struct list_head list_node;
  42         struct list_head trips;
  43         struct dentry *d_tt_zone;
  44         struct thermal_zone_device *tz;
  45         struct mutex lock;
  46         struct ida ida;
  47         int id;
  48         int temp;
  49         int tz_temp;
  50         unsigned int num_trips;
  51         unsigned int refcount;
  52 };
  53
  54 DEFINE_GUARD(tt_zone, struct tt_thermal_zone *, mutex_lock(&_T->lock), mutex_unlock(&_T->lock))
  55
  56 /**
  57  * struct tt_trip - Testing trip point template
  58  *
  59  * Represents a template of a trip point to be used for populating a trip point
  60  * during the registration of a thermal zone based on a given zone template.
  61  *
  62  * @list_node: Node in the list of all trip templates in the zone template.
  63  * @trip: Trip point data to use for thernal zone registration.
  64  * @id: The ID of this trip template for the debugfs interface.
  65  */
  66 struct tt_trip {
  67         struct list_head list_node;
  68         struct thermal_trip trip;
  69         int id;
  70 };
  71
  72 /*
  73  * It is both questionable and potentially problematic from the sychnronization
  74  * perspective to attempt to manipulate debugfs from within a debugfs file
  75  * "write" operation, so auxiliary work items are used for that.  The majority
  76  * of zone-related command functions have a part that runs from a workqueue and
  77  * make changes in debugs, among other things.
  78  */
  79 struct tt_work {
  80         struct work_struct work;
  81         struct tt_thermal_zone *tt_zone;
  82         struct tt_trip *tt_trip;
  83 };
  84
  85 static inline struct tt_work *tt_work_of_work(struct work_struct *work)
  86 {
  87         return container_of(work, struct tt_work, work);
  88 }
  89
  90 static LIST_HEAD(tt_thermal_zones);
  91 static DEFINE_IDA(tt_thermal_zones_ida);
  92 static DEFINE_MUTEX(tt_thermal_zones_lock);
  93
  94 static int tt_int_get(void *data, u64 *val)
  95 {
  96         *val = *(int *)data;
  97         return 0;
  98 }
  99 static int tt_int_set(void *data, u64 val)
 100 {
 101         if ((int)val < THERMAL_TEMP_INVALID)
 102                 return -EINVAL;
 103
 104         *(int *)data = val;
 105         return 0;
 106 }
 107 DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(tt_int_attr, tt_int_get, tt_int_set, "%lld\n");
 108 DEFINE_DEBUGFS_ATTRIBUTE(tt_unsigned_int_attr, tt_int_get, tt_int_set, "%llu\n");
 109
 110 static int tt_zone_tz_temp_get(void *data, u64 *val)
 111 {
 112         struct tt_thermal_zone *tt_zone = data;
 113
 114         guard(tt_zone)(tt_zone);
 115
 116         if (!tt_zone->tz)
 117                 return -EBUSY;
 118
 119         *val = tt_zone->tz_temp;
 120
 121         return 0;
 122 }
 123 static int tt_zone_tz_temp_set(void *data, u64 val)
 124 {
 125         struct tt_thermal_zone *tt_zone = data;
 126
 127         guard(tt_zone)(tt_zone);
 128
 129         if (!tt_zone->tz)
 130                 return -EBUSY;
 131
 132         WRITE_ONCE(tt_zone->tz_temp, val);
 133         thermal_zone_device_update(tt_zone->tz, THERMAL_EVENT_TEMP_SAMPLE);
 134
 135         return 0;
 136 }
 137 DEFINE_DEBUGFS_ATTRIBUTE_SIGNED(tt_zone_tz_temp_attr, tt_zone_tz_temp_get,
 138                                 tt_zone_tz_temp_set, "%lld\n");
 139
 140 static void tt_zone_free_trips(struct tt_thermal_zone *tt_zone)
 141 {
 142         struct tt_trip *tt_trip, *aux;
 143
 144         list_for_each_entry_safe(tt_trip, aux, &tt_zone->trips, list_node) {
 145                 list_del(&tt_trip->list_node);
 146                 ida_free(&tt_zone->ida, tt_trip->id);
 147                 kfree(tt_trip);
 148         }
 149 }
 150
 151 static void tt_zone_free(struct tt_thermal_zone *tt_zone)
 152 {
 153         tt_zone_free_trips(tt_zone);
 154         ida_free(&tt_thermal_zones_ida, tt_zone->id);
 155         ida_destroy(&tt_zone->ida);
 156         kfree(tt_zone);
 157 }
 158
 159 static void tt_add_tz_work_fn(struct work_struct *work)
 160 {
 161         struct tt_work *tt_work = tt_work_of_work(work);
 162         struct tt_thermal_zone *tt_zone = tt_work->tt_zone;
 163         char f_name[TT_MAX_FILE_NAME_LENGTH];
 164
 165         kfree(tt_work);
 166
 167         snprintf(f_name, TT_MAX_FILE_NAME_LENGTH, "tz%d", tt_zone->id);
 168         tt_zone->d_tt_zone = debugfs_create_dir(f_name, d_testing);
 169         if (IS_ERR(tt_zone->d_tt_zone)) {
 170                 tt_zone_free(tt_zone);
 171                 return;
 172         }
 173
 174         debugfs_create_file_unsafe("temp", 0600, tt_zone->d_tt_zone, tt_zone,
 175                                    &tt_zone_tz_temp_attr);
 176
 177         debugfs_create_file_unsafe("init_temp", 0600, tt_zone->d_tt_zone,
 178                                    &tt_zone->temp, &tt_int_attr);
 179
 180         guard(mutex)(&tt_thermal_zones_lock);
 181
 182         list_add_tail(&tt_zone->list_node, &tt_thermal_zones);
 183 }
 184
 185 int tt_add_tz(void)
 186 {
 187         struct tt_thermal_zone *tt_zone __free(kfree);
 188         struct tt_work *tt_work __free(kfree) = NULL;
 189         int ret;
 190
 191         tt_zone = kzalloc(sizeof(*tt_zone), GFP_KERNEL);
 192         if (!tt_zone)
 193                 return -ENOMEM;
 194
 195         tt_work = kzalloc(sizeof(*tt_work), GFP_KERNEL);
 196         if (!tt_work)
 197                 return -ENOMEM;
 198
 199         INIT_LIST_HEAD(&tt_zone->trips);
 200         mutex_init(&tt_zone->lock);
 201         ida_init(&tt_zone->ida);
 202         tt_zone->temp = THERMAL_TEMP_INVALID;
 203
 204         ret = ida_alloc(&tt_thermal_zones_ida, GFP_KERNEL);
 205         if (ret < 0)
 206                 return ret;
 207
 208         tt_zone->id = ret;
 209
 210         INIT_WORK(&tt_work->work, tt_add_tz_work_fn);
 211         tt_work->tt_zone = no_free_ptr(tt_zone);
 212         schedule_work(&(no_free_ptr(tt_work)->work));
 213
 214         return 0;
 215 }
 216
 217 static void tt_del_tz_work_fn(struct work_struct *work)
 218 {
 219         struct tt_work *tt_work = tt_work_of_work(work);
 220         struct tt_thermal_zone *tt_zone = tt_work->tt_zone;
 221
 222         kfree(tt_work);
 223
 224         debugfs_remove(tt_zone->d_tt_zone);
 225         tt_zone_free(tt_zone);
 226 }
 227
 228 static void tt_zone_unregister_tz(struct tt_thermal_zone *tt_zone)
 229 {
 230         guard(tt_zone)(tt_zone);
 231
 232         if (tt_zone->tz) {
 233                 thermal_zone_device_unregister(tt_zone->tz);
 234                 tt_zone->tz = NULL;
 235         }
 236 }
 237
 238 int tt_del_tz(const char *arg)
 239 {
 240         struct tt_work *tt_work __free(kfree) = NULL;
 241         struct tt_thermal_zone *tt_zone, *aux;
 242         int ret;
 243         int id;
 244
 245         ret = sscanf(arg, "%d", &id);
 246         if (ret != 1)
 247                 return -EINVAL;
 248
 249         tt_work = kzalloc(sizeof(*tt_work), GFP_KERNEL);
 250         if (!tt_work)
 251                 return -ENOMEM;
 252
 253         guard(mutex)(&tt_thermal_zones_lock);
 254
 255         ret = -EINVAL;
 256         list_for_each_entry_safe(tt_zone, aux, &tt_thermal_zones, list_node) {
 257                 if (tt_zone->id == id) {
 258                         if (tt_zone->refcount) {
 259                                 ret = -EBUSY;
 260                         } else {
 261                                 list_del(&tt_zone->list_node);
 262                                 ret = 0;
 263                         }
 264                         break;
 265                 }
 266         }
 267
 268         if (ret)
 269                 return ret;
 270
 271         tt_zone_unregister_tz(tt_zone);
 272
 273         INIT_WORK(&tt_work->work, tt_del_tz_work_fn);
 274         tt_work->tt_zone = tt_zone;
 275         schedule_work(&(no_free_ptr(tt_work)->work));
 276
 277         return 0;
 278 }
 279
 280 static struct tt_thermal_zone *tt_get_tt_zone(const char *arg)
 281 {
 282         struct tt_thermal_zone *tt_zone;
 283         int ret, id;
 284
 285         ret = sscanf(arg, "%d", &id);
 286         if (ret != 1)
 287                 return ERR_PTR(-EINVAL);
 288
 289         guard(mutex)(&tt_thermal_zones_lock);
 290
 291         list_for_each_entry(tt_zone, &tt_thermal_zones, list_node) {
 292                 if (tt_zone->id == id) {
 293                         tt_zone->refcount++;
 294                         return tt_zone;
 295                 }
 296         }
 297
 298         return ERR_PTR(-EINVAL);
 299 }
 300
 301 static void tt_put_tt_zone(struct tt_thermal_zone *tt_zone)
 302 {
 303         guard(mutex)(&tt_thermal_zones_lock);
 304
 305         tt_zone->refcount--;
 306 }
 307
 308 DEFINE_FREE(put_tt_zone, struct tt_thermal_zone *,
 309             if (!IS_ERR_OR_NULL(_T)) tt_put_tt_zone(_T))
 310
 311 static void tt_zone_add_trip_work_fn(struct work_struct *work)
 312 {
 313         struct tt_work *tt_work = tt_work_of_work(work);
 314         struct tt_thermal_zone *tt_zone = tt_work->tt_zone;
 315         struct tt_trip *tt_trip = tt_work->tt_trip;
 316         char d_name[TT_MAX_FILE_NAME_LENGTH];
 317
 318         kfree(tt_work);
 319
 320         snprintf(d_name, TT_MAX_FILE_NAME_LENGTH, "trip_%d_temp", tt_trip->id);
 321         debugfs_create_file_unsafe(d_name, 0600, tt_zone->d_tt_zone,
 322                                    &tt_trip->trip.temperature, &tt_int_attr);
 323
 324         snprintf(d_name, TT_MAX_FILE_NAME_LENGTH, "trip_%d_hyst", tt_trip->id);
 325         debugfs_create_file_unsafe(d_name, 0600, tt_zone->d_tt_zone,
 326                                    &tt_trip->trip.hysteresis, &tt_unsigned_int_attr);
 327
 328         tt_put_tt_zone(tt_zone);
 329 }
 330
 331 int tt_zone_add_trip(const char *arg)
 332 {
 333         struct tt_thermal_zone *tt_zone __free(put_tt_zone) = NULL;
 334         struct tt_trip *tt_trip __free(kfree) = NULL;
 335         struct tt_work *tt_work __free(kfree);
 336         int id;
 337
 338         tt_work = kzalloc(sizeof(*tt_work), GFP_KERNEL);
 339         if (!tt_work)
 340                 return -ENOMEM;
 341
 342         tt_trip = kzalloc(sizeof(*tt_trip), GFP_KERNEL);
 343         if (!tt_trip)
 344                 return -ENOMEM;
 345
 346         tt_zone = tt_get_tt_zone(arg);
 347         if (IS_ERR(tt_zone))
 348                 return PTR_ERR(tt_zone);
 349
 350         id = ida_alloc(&tt_zone->ida, GFP_KERNEL);
 351         if (id < 0)
 352                 return id;
 353
 354         tt_trip->trip.type = THERMAL_TRIP_ACTIVE;
 355         tt_trip->trip.temperature = THERMAL_TEMP_INVALID;
 356         tt_trip->trip.flags = THERMAL_TRIP_FLAG_RW;
 357         tt_trip->id = id;
 358
 359         guard(tt_zone)(tt_zone);
 360
 361         list_add_tail(&tt_trip->list_node, &tt_zone->trips);
 362         tt_zone->num_trips++;
 363
 364         INIT_WORK(&tt_work->work, tt_zone_add_trip_work_fn);
 365         tt_work->tt_zone = no_free_ptr(tt_zone);
 366         tt_work->tt_trip = no_free_ptr(tt_trip);
 367         schedule_work(&(no_free_ptr(tt_work)->work));
 368
 369         return 0;
 370 }
 371
 372 static int tt_zone_get_temp(struct thermal_zone_device *tz, int *temp)
 373 {
 374         struct tt_thermal_zone *tt_zone = thermal_zone_device_priv(tz);
 375
 376         *temp = READ_ONCE(tt_zone->tz_temp);
 377
 378         if (*temp < THERMAL_TEMP_INVALID)
 379                 return -ENODATA;
 380
 381         return 0;
 382 }
 383
 384 static struct thermal_zone_device_ops tt_zone_ops = {
 385         .get_temp = tt_zone_get_temp,
 386 };
 387
 388 static int tt_zone_register_tz(struct tt_thermal_zone *tt_zone)
 389 {
 390         struct thermal_trip *trips __free(kfree) = NULL;
 391         struct thermal_zone_device *tz;
 392         struct tt_trip *tt_trip;
 393         int i;
 394
 395         guard(tt_zone)(tt_zone);
 396
 397         if (tt_zone->tz)
 398                 return -EINVAL;
 399
 400         trips = kcalloc(tt_zone->num_trips, sizeof(*trips), GFP_KERNEL);
 401         if (!trips)
 402                 return -ENOMEM;
 403
 404         i = 0;
 405         list_for_each_entry(tt_trip, &tt_zone->trips, list_node)
 406                 trips[i++] = tt_trip->trip;
 407
 408         tt_zone->tz_temp = tt_zone->temp;
 409
 410         tz = thermal_zone_device_register_with_trips("test_tz", trips, i, tt_zone,
 411                                                      &tt_zone_ops, NULL, 0, 0);
 412         if (IS_ERR(tz))
 413                 return PTR_ERR(tz);
 414
 415         tt_zone->tz = tz;
 416
 417         thermal_zone_device_enable(tz);
 418
 419         return 0;
 420 }
 421
 422 int tt_zone_reg(const char *arg)
 423 {
 424         struct tt_thermal_zone *tt_zone __free(put_tt_zone);
 425
 426         tt_zone = tt_get_tt_zone(arg);
 427         if (IS_ERR(tt_zone))
 428                 return PTR_ERR(tt_zone);
 429
 430         return tt_zone_register_tz(tt_zone);
 431 }
 432
 433 int tt_zone_unreg(const char *arg)
 434 {
 435         struct tt_thermal_zone *tt_zone __free(put_tt_zone);
 436
 437         tt_zone = tt_get_tt_zone(arg);
 438         if (IS_ERR(tt_zone))
 439                 return PTR_ERR(tt_zone);
 440
 441         tt_zone_unregister_tz(tt_zone);
 442
 443         return 0;
 444 }
 445
 446 void tt_zone_cleanup(void)
 447 {
 448         struct tt_thermal_zone *tt_zone, *aux;
 449
 450         list_for_each_entry_safe(tt_zone, aux, &tt_thermal_zones, list_node) {
 451                 tt_zone_unregister_tz(tt_zone);
 452
 453                 list_del(&tt_zone->list_node);
 454
 455                 tt_zone_free(tt_zone);
 456         }
 457 }