drivers/hwtracing/coresight/coresight-trace-id.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2022, Linaro Limited, All rights reserved.
   4  * Author: Mike Leach <mike.leach@linaro.org>
   5  */
   6 #include <linux/coresight.h>
   7 #include <linux/coresight-pmu.h>
   8 #include <linux/cpumask.h>
   9 #include <linux/kernel.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/types.h>
  12
  13 #include "coresight-trace-id.h"
  14
  15 /* Default trace ID map. Used in sysfs mode and for system sources */
  16 static DEFINE_PER_CPU(atomic_t, id_map_default_cpu_ids) = ATOMIC_INIT(0);
  17 static struct coresight_trace_id_map id_map_default = {
  18         .cpu_map = &id_map_default_cpu_ids,
  19         .lock = __SPIN_LOCK_UNLOCKED(id_map_default.lock)
  20 };
  21
  22 /* #define TRACE_ID_DEBUG 1 */
  23 #if defined(TRACE_ID_DEBUG) || defined(CONFIG_COMPILE_TEST)
  24
  25 static void coresight_trace_id_dump_table(struct coresight_trace_id_map *id_map,
  26                                           const char *func_name)
  27 {
  28         pr_debug("%s id_map::\n", func_name);
  29         pr_debug("Used = %*pb\n", CORESIGHT_TRACE_IDS_MAX, id_map->used_ids);
  30 }
  31 #define DUMP_ID_MAP(map)   coresight_trace_id_dump_table(map, __func__)
  32 #define DUMP_ID_CPU(cpu, id) pr_debug("%s called;  cpu=%d, id=%d\n", __func__, cpu, id)
  33 #define DUMP_ID(id)   pr_debug("%s called; id=%d\n", __func__, id)
  34 #define PERF_SESSION(n) pr_debug("%s perf count %d\n", __func__, n)
  35 #else
  36 #define DUMP_ID_MAP(map)
  37 #define DUMP_ID(id)
  38 #define DUMP_ID_CPU(cpu, id)
  39 #define PERF_SESSION(n)
  40 #endif
  41
  42 /* unlocked read of current trace ID value for given CPU */
  43 static int _coresight_trace_id_read_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
  44 {
  45         return atomic_read(per_cpu_ptr(id_map->cpu_map, cpu));
  46 }
  47
  48 /* look for next available odd ID, return 0 if none found */
  49 static int coresight_trace_id_find_odd_id(struct coresight_trace_id_map *id_map)
  50 {
  51         int found_id = 0, bit = 1, next_id;
  52
  53         while ((bit < CORESIGHT_TRACE_ID_RES_TOP) && !found_id) {
  54                 /*
  55                  * bitmap length of CORESIGHT_TRACE_ID_RES_TOP,
  56                  * search from offset `bit`.
  57                  */
  58                 next_id = find_next_zero_bit(id_map->used_ids,
  59                                              CORESIGHT_TRACE_ID_RES_TOP, bit);
  60                 if ((next_id < CORESIGHT_TRACE_ID_RES_TOP) && (next_id & 0x1))
  61                         found_id = next_id;
  62                 else
  63                         bit = next_id + 1;
  64         }
  65         return found_id;
  66 }
  67
  68 /*
  69  * Allocate new ID and set in use
  70  *
  71  * if @preferred_id is a valid id then try to use that value if available.
  72  * if @preferred_id is not valid and @prefer_odd_id is true, try for odd id.
  73  *
  74  * Otherwise allocate next available ID.
  75  */
  76 static int coresight_trace_id_alloc_new_id(struct coresight_trace_id_map *id_map,
  77                                            int preferred_id, bool prefer_odd_id)
  78 {
  79         int id = 0;
  80
  81         /* for backwards compatibility, cpu IDs may use preferred value */
  82         if (IS_VALID_CS_TRACE_ID(preferred_id) &&
  83             !test_bit(preferred_id, id_map->used_ids)) {
  84                 id = preferred_id;
  85                 goto trace_id_allocated;
  86         } else if (prefer_odd_id) {
  87         /* may use odd ids to avoid preferred legacy cpu IDs */
  88                 id = coresight_trace_id_find_odd_id(id_map);
  89                 if (id)
  90                         goto trace_id_allocated;
  91         }
  92
  93         /*
  94          * skip reserved bit 0, look at bitmap length of
  95          * CORESIGHT_TRACE_ID_RES_TOP from offset of bit 1.
  96          */
  97         id = find_next_zero_bit(id_map->used_ids, CORESIGHT_TRACE_ID_RES_TOP, 1);
  98         if (id >= CORESIGHT_TRACE_ID_RES_TOP)
  99                 return -EINVAL;
 100
 101         /* mark as used */
 102 trace_id_allocated:
 103         set_bit(id, id_map->used_ids);
 104         return id;
 105 }
 106
 107 static void coresight_trace_id_free(int id, struct coresight_trace_id_map *id_map)
 108 {
 109         if (WARN(!IS_VALID_CS_TRACE_ID(id), "Invalid Trace ID %d\n", id))
 110                 return;
 111         if (WARN(!test_bit(id, id_map->used_ids), "Freeing unused ID %d\n", id))
 112                 return;
 113         clear_bit(id, id_map->used_ids);
 114 }
 115
 116 /*
 117  * Release all IDs and clear CPU associations.
 118  */
 119 static void coresight_trace_id_release_all(struct coresight_trace_id_map *id_map)
 120 {
 121         unsigned long flags;
 122         int cpu;
 123
 124         spin_lock_irqsave(&id_map->lock, flags);
 125         bitmap_zero(id_map->used_ids, CORESIGHT_TRACE_IDS_MAX);
 126         for_each_possible_cpu(cpu)
 127                 atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);
 128         spin_unlock_irqrestore(&id_map->lock, flags);
 129         DUMP_ID_MAP(id_map);
 130 }
 131
 132 static int _coresight_trace_id_get_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
 133 {
 134         unsigned long flags;
 135         int id;
 136
 137         spin_lock_irqsave(&id_map->lock, flags);
 138
 139         /* check for existing allocation for this CPU */
 140         id = _coresight_trace_id_read_cpu_id(cpu, id_map);
 141         if (id)
 142                 goto get_cpu_id_out_unlock;
 143
 144         /*
 145          * Find a new ID.
 146          *
 147          * Use legacy values where possible in the dynamic trace ID allocator to
 148          * allow older tools to continue working if they are not upgraded at the
 149          * same time as the kernel drivers.
 150          *
 151          * If the generated legacy ID is invalid, or not available then the next
 152          * available dynamic ID will be used.
 153          */
 154         id = coresight_trace_id_alloc_new_id(id_map,
 155                                              CORESIGHT_LEGACY_CPU_TRACE_ID(cpu),
 156                                              false);
 157         if (!IS_VALID_CS_TRACE_ID(id))
 158                 goto get_cpu_id_out_unlock;
 159
 160         /* allocate the new id to the cpu */
 161         atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), id);
 162
 163 get_cpu_id_out_unlock:
 164         spin_unlock_irqrestore(&id_map->lock, flags);
 165
 166         DUMP_ID_CPU(cpu, id);
 167         DUMP_ID_MAP(id_map);
 168         return id;
 169 }
 170
 171 static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
 172 {
 173         unsigned long flags;
 174         int id;
 175
 176         /* check for existing allocation for this CPU */
 177         id = _coresight_trace_id_read_cpu_id(cpu, id_map);
 178         if (!id)
 179                 return;
 180
 181         spin_lock_irqsave(&id_map->lock, flags);
 182
 183         coresight_trace_id_free(id, id_map);
 184         atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);
 185
 186         spin_unlock_irqrestore(&id_map->lock, flags);
 187         DUMP_ID_CPU(cpu, id);
 188         DUMP_ID_MAP(id_map);
 189 }
 190
 191 static int coresight_trace_id_map_get_system_id(struct coresight_trace_id_map *id_map)
 192 {
 193         unsigned long flags;
 194         int id;
 195
 196         spin_lock_irqsave(&id_map->lock, flags);
 197         /* prefer odd IDs for system components to avoid legacy CPU IDS */
 198         id = coresight_trace_id_alloc_new_id(id_map, 0, true);
 199         spin_unlock_irqrestore(&id_map->lock, flags);
 200
 201         DUMP_ID(id);
 202         DUMP_ID_MAP(id_map);
 203         return id;
 204 }
 205
 206 static void coresight_trace_id_map_put_system_id(struct coresight_trace_id_map *id_map, int id)
 207 {
 208         unsigned long flags;
 209
 210         spin_lock_irqsave(&id_map->lock, flags);
 211         coresight_trace_id_free(id, id_map);
 212         spin_unlock_irqrestore(&id_map->lock, flags);
 213
 214         DUMP_ID(id);
 215         DUMP_ID_MAP(id_map);
 216 }
 217
 218 /* API functions */
 219
 220 int coresight_trace_id_get_cpu_id(int cpu)
 221 {
 222         return _coresight_trace_id_get_cpu_id(cpu, &id_map_default);
 223 }
 224 EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id);
 225
 226 int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
 227 {
 228         return _coresight_trace_id_get_cpu_id(cpu, id_map);
 229 }
 230 EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id_map);
 231
 232 void coresight_trace_id_put_cpu_id(int cpu)
 233 {
 234         _coresight_trace_id_put_cpu_id(cpu, &id_map_default);
 235 }
 236 EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id);
 237
 238 void coresight_trace_id_put_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
 239 {
 240         _coresight_trace_id_put_cpu_id(cpu, id_map);
 241 }
 242 EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id_map);
 243
 244 int coresight_trace_id_read_cpu_id(int cpu)
 245 {
 246         return _coresight_trace_id_read_cpu_id(cpu, &id_map_default);
 247 }
 248 EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id);
 249
 250 int coresight_trace_id_read_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
 251 {
 252         return _coresight_trace_id_read_cpu_id(cpu, id_map);
 253 }
 254 EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id_map);
 255
 256 int coresight_trace_id_get_system_id(void)
 257 {
 258         return coresight_trace_id_map_get_system_id(&id_map_default);
 259 }
 260 EXPORT_SYMBOL_GPL(coresight_trace_id_get_system_id);
 261
 262 void coresight_trace_id_put_system_id(int id)
 263 {
 264         coresight_trace_id_map_put_system_id(&id_map_default, id);
 265 }
 266 EXPORT_SYMBOL_GPL(coresight_trace_id_put_system_id);
 267
 268 void coresight_trace_id_perf_start(struct coresight_trace_id_map *id_map)
 269 {
 270         atomic_inc(&id_map->perf_cs_etm_session_active);
 271         PERF_SESSION(atomic_read(&id_map->perf_cs_etm_session_active));
 272 }
 273 EXPORT_SYMBOL_GPL(coresight_trace_id_perf_start);
 274
 275 void coresight_trace_id_perf_stop(struct coresight_trace_id_map *id_map)
 276 {
 277         if (!atomic_dec_return(&id_map->perf_cs_etm_session_active))
 278                 coresight_trace_id_release_all(id_map);
 279         PERF_SESSION(atomic_read(&id_map->perf_cs_etm_session_active));
 280 }
 281 EXPORT_SYMBOL_GPL(coresight_trace_id_perf_stop);