drivers/thermal/testing/zone.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2024, Intel Corporation
   4  *
   5  * Author: Rafael J. Wysocki <[email protected]>
   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);
 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);
 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         ret = -EINVAL;
 292         list_for_each_entry(tt_zone, &tt_thermal_zones, list_node) {
 293                 if (tt_zone->id == id) {
 294                         tt_zone->refcount++;
 295                         ret = 0;
 296                         break;
 297                 }
 298         }
 299
 300         if (ret)
 301                 return ERR_PTR(ret);
 302
 303         return tt_zone;
 304 }
 305
 306 static void tt_put_tt_zone(struct tt_thermal_zone *tt_zone)
 307 {
 308         guard(mutex)(&tt_thermal_zones_lock);
 309
 310         tt_zone->refcount--;
 311 }
 312
 313 static void tt_zone_add_trip_work_fn(struct work_struct *work)
 314 {
 315         struct tt_work *tt_work = tt_work_of_work(work);
 316         struct tt_thermal_zone *tt_zone = tt_work->tt_zone;
 317         struct tt_trip *tt_trip = tt_work->tt_trip;
 318         char d_name[TT_MAX_FILE_NAME_LENGTH];
 319
 320         kfree(tt_work);
 321
 322         snprintf(d_name, TT_MAX_FILE_NAME_LENGTH, "trip_%d_temp", tt_trip->id);
 323         debugfs_create_file_unsafe(d_name, 0600, tt_zone->d_tt_zone,
 324                                    &tt_trip->trip.temperature, &tt_int_attr);
 325
 326         snprintf(d_name, TT_MAX_FILE_NAME_LENGTH, "trip_%d_hyst", tt_trip->id);
 327         debugfs_create_file_unsafe(d_name, 0600, tt_zone->d_tt_zone,
 328                                    &tt_trip->trip.hysteresis, &tt_unsigned_int_attr);
 329
 330         tt_put_tt_zone(tt_zone);
 331 }
 332
 333 int tt_zone_add_trip(const char *arg)
 334 {
 335         struct tt_work *tt_work __free(kfree);
 336         struct tt_trip *tt_trip __free(kfree);
 337         struct tt_thermal_zone *tt_zone;
 338         int id;
 339
 340         tt_work = kzalloc(sizeof(*tt_work), GFP_KERNEL);
 341         if (!tt_work)
 342                 return -ENOMEM;
 343
 344         tt_trip = kzalloc(sizeof(*tt_trip), GFP_KERNEL);
 345         if (!tt_trip)
 346                 return -ENOMEM;
 347
 348         tt_zone = tt_get_tt_zone(arg);
 349         if (IS_ERR(tt_zone))
 350                 return PTR_ERR(tt_zone);
 351
 352         id = ida_alloc(&tt_zone->ida, GFP_KERNEL);
 353         if (id < 0) {
 354                 tt_put_tt_zone(tt_zone);
 355                 return id;
 356         }
 357
 358         tt_trip->trip.type = THERMAL_TRIP_ACTIVE;
 359         tt_trip->trip.temperature = THERMAL_TEMP_INVALID;
 360         tt_trip->trip.flags = THERMAL_TRIP_FLAG_RW;
 361         tt_trip->id = id;
 362
 363         guard(tt_zone)(tt_zone);
 364
 365         list_add_tail(&tt_trip->list_node, &tt_zone->trips);
 366         tt_zone->num_trips++;
 367
 368         INIT_WORK(&tt_work->work, tt_zone_add_trip_work_fn);
 369         tt_work->tt_zone = tt_zone;
 370         tt_work->tt_trip = no_free_ptr(tt_trip);
 371         schedule_work(&(no_free_ptr(tt_work)->work));
 372
 373         return 0;
 374 }
 375
 376 static int tt_zone_get_temp(struct thermal_zone_device *tz, int *temp)
 377 {
 378         struct tt_thermal_zone *tt_zone = thermal_zone_device_priv(tz);
 379
 380         *temp = READ_ONCE(tt_zone->tz_temp);
 381
 382         if (*temp < THERMAL_TEMP_INVALID)
 383                 return -ENODATA;
 384
 385         return 0;
 386 }
 387
 388 static struct thermal_zone_device_ops tt_zone_ops = {
 389         .get_temp = tt_zone_get_temp,
 390 };
 391
 392 static int tt_zone_register_tz(struct tt_thermal_zone *tt_zone)
 393 {
 394         struct thermal_trip *trips __free(kfree);
 395         struct thermal_zone_device *tz;
 396         struct tt_trip *tt_trip;
 397         int i;
 398
 399         guard(tt_zone)(tt_zone);
 400
 401         if (tt_zone->tz)
 402                 return -EINVAL;
 403
 404         trips = kcalloc(tt_zone->num_trips, sizeof(*trips), GFP_KERNEL);
 405         if (!trips)
 406                 return -ENOMEM;
 407
 408         i = 0;
 409         list_for_each_entry(tt_trip, &tt_zone->trips, list_node)
 410                 trips[i++] = tt_trip->trip;
 411
 412         tt_zone->tz_temp = tt_zone->temp;
 413
 414         tz = thermal_zone_device_register_with_trips("test_tz", trips, i, tt_zone,
 415                                                      &tt_zone_ops, NULL, 0, 0);
 416         if (IS_ERR(tz))
 417                 return PTR_ERR(tz);
 418
 419         tt_zone->tz = tz;
 420
 421         thermal_zone_device_enable(tz);
 422
 423         return 0;
 424 }
 425
 426 int tt_zone_reg(const char *arg)
 427 {
 428         struct tt_thermal_zone *tt_zone;
 429         int ret;
 430
 431         tt_zone = tt_get_tt_zone(arg);
 432         if (IS_ERR(tt_zone))
 433                 return PTR_ERR(tt_zone);
 434
 435         ret = tt_zone_register_tz(tt_zone);
 436
 437         tt_put_tt_zone(tt_zone);
 438
 439         return ret;
 440 }
 441
 442 int tt_zone_unreg(const char *arg)
 443 {
 444         struct tt_thermal_zone *tt_zone;
 445
 446         tt_zone = tt_get_tt_zone(arg);
 447         if (IS_ERR(tt_zone))
 448                 return PTR_ERR(tt_zone);
 449
 450         tt_zone_unregister_tz(tt_zone);
 451
 452         tt_put_tt_zone(tt_zone);
 453
 454         return 0;
 455 }
 456
 457 void tt_zone_cleanup(void)
 458 {
 459         struct tt_thermal_zone *tt_zone, *aux;
 460
 461         list_for_each_entry_safe(tt_zone, aux, &tt_thermal_zones, list_node) {
 462                 tt_zone_unregister_tz(tt_zone);
 463
 464                 list_del(&tt_zone->list_node);
 465
 466                 tt_zone_free(tt_zone);
 467         }
 468 }