drivers/perf/qcom_l3_pmu.c

   1 /*
   2  * Driver for the L3 cache PMUs in Qualcomm Technologies chips.
   3  *
   4  * The driver supports a distributed cache architecture where the overall
   5  * cache for a socket is comprised of multiple slices each with its own PMU.
   6  * Access to each individual PMU is provided even though all CPUs share all
   7  * the slices. User space needs to aggregate to individual counts to provide
   8  * a global picture.
   9  *
  10  * See Documentation/perf/qcom_l3_pmu.txt for more details.
  11  *
  12  * Copyright (c) 2015-2017, The Linux Foundation. All rights reserved.
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License version 2 and
  16  * only version 2 as published by the Free Software Foundation.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  */
  23
  24 #include <linux/acpi.h>
  25 #include <linux/bitops.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/io.h>
  28 #include <linux/list.h>
  29 #include <linux/module.h>
  30 #include <linux/perf_event.h>
  31 #include <linux/platform_device.h>
  32
  33 /*
  34  * General constants
  35  */
  36
  37 /* Number of counters on each PMU */
  38 #define L3_NUM_COUNTERS  8
  39 /* Mask for the event type field within perf_event_attr.config and EVTYPE reg */
  40 #define L3_EVTYPE_MASK   0xFF
  41 /*
  42  * Bit position of the 'long counter' flag within perf_event_attr.config.
  43  * Reserve some space between the event type and this flag to allow expansion
  44  * in the event type field.
  45  */
  46 #define L3_EVENT_LC_BIT  32
  47
  48 /*
  49  * Register offsets
  50  */
  51
  52 /* Perfmon registers */
  53 #define L3_HML3_PM_CR       0x000
  54 #define L3_HML3_PM_EVCNTR(__cntr) (0x420 + ((__cntr) & 0x7) * 8)
  55 #define L3_HML3_PM_CNTCTL(__cntr) (0x120 + ((__cntr) & 0x7) * 8)
  56 #define L3_HML3_PM_EVTYPE(__cntr) (0x220 + ((__cntr) & 0x7) * 8)
  57 #define L3_HML3_PM_FILTRA   0x300
  58 #define L3_HML3_PM_FILTRB   0x308
  59 #define L3_HML3_PM_FILTRC   0x310
  60 #define L3_HML3_PM_FILTRAM  0x304
  61 #define L3_HML3_PM_FILTRBM  0x30C
  62 #define L3_HML3_PM_FILTRCM  0x314
  63
  64 /* Basic counter registers */
  65 #define L3_M_BC_CR         0x500
  66 #define L3_M_BC_SATROLL_CR 0x504
  67 #define L3_M_BC_CNTENSET   0x508
  68 #define L3_M_BC_CNTENCLR   0x50C
  69 #define L3_M_BC_INTENSET   0x510
  70 #define L3_M_BC_INTENCLR   0x514
  71 #define L3_M_BC_GANG       0x718
  72 #define L3_M_BC_OVSR       0x740
  73 #define L3_M_BC_IRQCTL     0x96C
  74
  75 /*
  76  * Bit field definitions
  77  */
  78
  79 /* L3_HML3_PM_CR */
  80 #define PM_CR_RESET           (0)
  81
  82 /* L3_HML3_PM_XCNTCTL/L3_HML3_PM_CNTCTLx */
  83 #define PMCNT_RESET           (0)
  84
  85 /* L3_HML3_PM_EVTYPEx */
  86 #define EVSEL(__val)          ((__val) & L3_EVTYPE_MASK)
  87
  88 /* Reset value for all the filter registers */
  89 #define PM_FLTR_RESET         (0)
  90
  91 /* L3_M_BC_CR */
  92 #define BC_RESET              (1UL << 1)
  93 #define BC_ENABLE             (1UL << 0)
  94
  95 /* L3_M_BC_SATROLL_CR */
  96 #define BC_SATROLL_CR_RESET   (0)
  97
  98 /* L3_M_BC_CNTENSET */
  99 #define PMCNTENSET(__cntr)    (1UL << ((__cntr) & 0x7))
 100
 101 /* L3_M_BC_CNTENCLR */
 102 #define PMCNTENCLR(__cntr)    (1UL << ((__cntr) & 0x7))
 103 #define BC_CNTENCLR_RESET     (0xFF)
 104
 105 /* L3_M_BC_INTENSET */
 106 #define PMINTENSET(__cntr)    (1UL << ((__cntr) & 0x7))
 107
 108 /* L3_M_BC_INTENCLR */
 109 #define PMINTENCLR(__cntr)    (1UL << ((__cntr) & 0x7))
 110 #define BC_INTENCLR_RESET     (0xFF)
 111
 112 /* L3_M_BC_GANG */
 113 #define GANG_EN(__cntr)       (1UL << ((__cntr) & 0x7))
 114 #define BC_GANG_RESET         (0)
 115
 116 /* L3_M_BC_OVSR */
 117 #define PMOVSRCLR(__cntr)     (1UL << ((__cntr) & 0x7))
 118 #define PMOVSRCLR_RESET       (0xFF)
 119
 120 /* L3_M_BC_IRQCTL */
 121 #define PMIRQONMSBEN(__cntr)  (1UL << ((__cntr) & 0x7))
 122 #define BC_IRQCTL_RESET       (0x0)
 123
 124 /*
 125  * Events
 126  */
 127
 128 #define L3_EVENT_CYCLES         0x01
 129 #define L3_EVENT_READ_HIT               0x20
 130 #define L3_EVENT_READ_MISS              0x21
 131 #define L3_EVENT_READ_HIT_D             0x22
 132 #define L3_EVENT_READ_MISS_D            0x23
 133 #define L3_EVENT_WRITE_HIT              0x24
 134 #define L3_EVENT_WRITE_MISS             0x25
 135
 136 /*
 137  * Decoding of settings from perf_event_attr
 138  *
 139  * The config format for perf events is:
 140  * - config: bits 0-7: event type
 141  *           bit  32:  HW counter size requested, 0: 32 bits, 1: 64 bits
 142  */
 143
 144 static inline u32 get_event_type(struct perf_event *event)
 145 {
 146         return (event->attr.config) & L3_EVTYPE_MASK;
 147 }
 148
 149 static inline bool event_uses_long_counter(struct perf_event *event)
 150 {
 151         return !!(event->attr.config & BIT_ULL(L3_EVENT_LC_BIT));
 152 }
 153
 154 static inline int event_num_counters(struct perf_event *event)
 155 {
 156         return event_uses_long_counter(event) ? 2 : 1;
 157 }
 158
 159 /*
 160  * Main PMU, inherits from the core perf PMU type
 161  */
 162 struct l3cache_pmu {
 163         struct pmu              pmu;
 164         struct hlist_node       node;
 165         void __iomem            *regs;
 166         struct perf_event       *events[L3_NUM_COUNTERS];
 167         unsigned long           used_mask[BITS_TO_LONGS(L3_NUM_COUNTERS)];
 168         cpumask_t               cpumask;
 169 };
 170
 171 #define to_l3cache_pmu(p) (container_of(p, struct l3cache_pmu, pmu))
 172
 173 /*
 174  * Type used to group hardware counter operations
 175  *
 176  * Used to implement two types of hardware counters, standard (32bits) and
 177  * long (64bits). The hardware supports counter chaining which we use to
 178  * implement long counters. This support is exposed via the 'lc' flag field
 179  * in perf_event_attr.config.
 180  */
 181 struct l3cache_event_ops {
 182         /* Called to start event monitoring */
 183         void (*start)(struct perf_event *event);
 184         /* Called to stop event monitoring */
 185         void (*stop)(struct perf_event *event, int flags);
 186         /* Called to update the perf_event */
 187         void (*update)(struct perf_event *event);
 188 };
 189
 190 /*
 191  * Implementation of long counter operations
 192  *
 193  * 64bit counters are implemented by chaining two of the 32bit physical
 194  * counters. The PMU only supports chaining of adjacent even/odd pairs
 195  * and for simplicity the driver always configures the odd counter to
 196  * count the overflows of the lower-numbered even counter. Note that since
 197  * the resulting hardware counter is 64bits no IRQs are required to maintain
 198  * the software counter which is also 64bits.
 199  */
 200
 201 static void qcom_l3_cache__64bit_counter_start(struct perf_event *event)
 202 {
 203         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 204         int idx = event->hw.idx;
 205         u32 evsel = get_event_type(event);
 206         u32 gang;
 207
 208         /* Set the odd counter to count the overflows of the even counter */
 209         gang = readl_relaxed(l3pmu->regs + L3_M_BC_GANG);
 210         gang |= GANG_EN(idx + 1);
 211         writel_relaxed(gang, l3pmu->regs + L3_M_BC_GANG);
 212
 213         /* Initialize the hardware counters and reset prev_count*/
 214         local64_set(&event->hw.prev_count, 0);
 215         writel_relaxed(0, l3pmu->regs + L3_HML3_PM_EVCNTR(idx + 1));
 216         writel_relaxed(0, l3pmu->regs + L3_HML3_PM_EVCNTR(idx));
 217
 218         /*
 219          * Set the event types, the upper half must use zero and the lower
 220          * half the actual event type
 221          */
 222         writel_relaxed(EVSEL(0), l3pmu->regs + L3_HML3_PM_EVTYPE(idx + 1));
 223         writel_relaxed(EVSEL(evsel), l3pmu->regs + L3_HML3_PM_EVTYPE(idx));
 224
 225         /* Finally, enable the counters */
 226         writel_relaxed(PMCNT_RESET, l3pmu->regs + L3_HML3_PM_CNTCTL(idx + 1));
 227         writel_relaxed(PMCNTENSET(idx + 1), l3pmu->regs + L3_M_BC_CNTENSET);
 228         writel_relaxed(PMCNT_RESET, l3pmu->regs + L3_HML3_PM_CNTCTL(idx));
 229         writel_relaxed(PMCNTENSET(idx), l3pmu->regs + L3_M_BC_CNTENSET);
 230 }
 231
 232 static void qcom_l3_cache__64bit_counter_stop(struct perf_event *event,
 233                                               int flags)
 234 {
 235         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 236         int idx = event->hw.idx;
 237         u32 gang = readl_relaxed(l3pmu->regs + L3_M_BC_GANG);
 238
 239         /* Disable the counters */
 240         writel_relaxed(PMCNTENCLR(idx), l3pmu->regs + L3_M_BC_CNTENCLR);
 241         writel_relaxed(PMCNTENCLR(idx + 1), l3pmu->regs + L3_M_BC_CNTENCLR);
 242
 243         /* Disable chaining */
 244         writel_relaxed(gang & ~GANG_EN(idx + 1), l3pmu->regs + L3_M_BC_GANG);
 245 }
 246
 247 static void qcom_l3_cache__64bit_counter_update(struct perf_event *event)
 248 {
 249         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 250         int idx = event->hw.idx;
 251         u32 hi, lo;
 252         u64 prev, new;
 253
 254         do {
 255                 prev = local64_read(&event->hw.prev_count);
 256                 do {
 257                         hi = readl_relaxed(l3pmu->regs + L3_HML3_PM_EVCNTR(idx + 1));
 258                         lo = readl_relaxed(l3pmu->regs + L3_HML3_PM_EVCNTR(idx));
 259                 } while (hi != readl_relaxed(l3pmu->regs + L3_HML3_PM_EVCNTR(idx + 1)));
 260                 new = ((u64)hi << 32) | lo;
 261         } while (local64_cmpxchg(&event->hw.prev_count, prev, new) != prev);
 262
 263         local64_add(new - prev, &event->count);
 264 }
 265
 266 static const struct l3cache_event_ops event_ops_long = {
 267         .start = qcom_l3_cache__64bit_counter_start,
 268         .stop = qcom_l3_cache__64bit_counter_stop,
 269         .update = qcom_l3_cache__64bit_counter_update,
 270 };
 271
 272 /*
 273  * Implementation of standard counter operations
 274  *
 275  * 32bit counters use a single physical counter and a hardware feature that
 276  * asserts the overflow IRQ on the toggling of the most significant bit in
 277  * the counter. This feature allows the counters to be left free-running
 278  * without needing the usual reprogramming required to properly handle races
 279  * during concurrent calls to update.
 280  */
 281
 282 static void qcom_l3_cache__32bit_counter_start(struct perf_event *event)
 283 {
 284         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 285         int idx = event->hw.idx;
 286         u32 evsel = get_event_type(event);
 287         u32 irqctl = readl_relaxed(l3pmu->regs + L3_M_BC_IRQCTL);
 288
 289         /* Set the counter to assert the overflow IRQ on MSB toggling */
 290         writel_relaxed(irqctl | PMIRQONMSBEN(idx), l3pmu->regs + L3_M_BC_IRQCTL);
 291
 292         /* Initialize the hardware counter and reset prev_count*/
 293         local64_set(&event->hw.prev_count, 0);
 294         writel_relaxed(0, l3pmu->regs + L3_HML3_PM_EVCNTR(idx));
 295
 296         /* Set the event type */
 297         writel_relaxed(EVSEL(evsel), l3pmu->regs + L3_HML3_PM_EVTYPE(idx));
 298
 299         /* Enable interrupt generation by this counter */
 300         writel_relaxed(PMINTENSET(idx), l3pmu->regs + L3_M_BC_INTENSET);
 301
 302         /* Finally, enable the counter */
 303         writel_relaxed(PMCNT_RESET, l3pmu->regs + L3_HML3_PM_CNTCTL(idx));
 304         writel_relaxed(PMCNTENSET(idx), l3pmu->regs + L3_M_BC_CNTENSET);
 305 }
 306
 307 static void qcom_l3_cache__32bit_counter_stop(struct perf_event *event,
 308                                               int flags)
 309 {
 310         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 311         int idx = event->hw.idx;
 312         u32 irqctl = readl_relaxed(l3pmu->regs + L3_M_BC_IRQCTL);
 313
 314         /* Disable the counter */
 315         writel_relaxed(PMCNTENCLR(idx), l3pmu->regs + L3_M_BC_CNTENCLR);
 316
 317         /* Disable interrupt generation by this counter */
 318         writel_relaxed(PMINTENCLR(idx), l3pmu->regs + L3_M_BC_INTENCLR);
 319
 320         /* Set the counter to not assert the overflow IRQ on MSB toggling */
 321         writel_relaxed(irqctl & ~PMIRQONMSBEN(idx), l3pmu->regs + L3_M_BC_IRQCTL);
 322 }
 323
 324 static void qcom_l3_cache__32bit_counter_update(struct perf_event *event)
 325 {
 326         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 327         int idx = event->hw.idx;
 328         u32 prev, new;
 329
 330         do {
 331                 prev = local64_read(&event->hw.prev_count);
 332                 new = readl_relaxed(l3pmu->regs + L3_HML3_PM_EVCNTR(idx));
 333         } while (local64_cmpxchg(&event->hw.prev_count, prev, new) != prev);
 334
 335         local64_add(new - prev, &event->count);
 336 }
 337
 338 static const struct l3cache_event_ops event_ops_std = {
 339         .start = qcom_l3_cache__32bit_counter_start,
 340         .stop = qcom_l3_cache__32bit_counter_stop,
 341         .update = qcom_l3_cache__32bit_counter_update,
 342 };
 343
 344 /* Retrieve the appropriate operations for the given event */
 345 static
 346 const struct l3cache_event_ops *l3cache_event_get_ops(struct perf_event *event)
 347 {
 348         if (event_uses_long_counter(event))
 349                 return &event_ops_long;
 350         else
 351                 return &event_ops_std;
 352 }
 353
 354 /*
 355  * Top level PMU functions.
 356  */
 357
 358 static inline void qcom_l3_cache__init(struct l3cache_pmu *l3pmu)
 359 {
 360         int i;
 361
 362         writel_relaxed(BC_RESET, l3pmu->regs + L3_M_BC_CR);
 363
 364         /*
 365          * Use writel for the first programming command to ensure the basic
 366          * counter unit is stopped before proceeding
 367          */
 368         writel(BC_SATROLL_CR_RESET, l3pmu->regs + L3_M_BC_SATROLL_CR);
 369
 370         writel_relaxed(BC_CNTENCLR_RESET, l3pmu->regs + L3_M_BC_CNTENCLR);
 371         writel_relaxed(BC_INTENCLR_RESET, l3pmu->regs + L3_M_BC_INTENCLR);
 372         writel_relaxed(PMOVSRCLR_RESET, l3pmu->regs + L3_M_BC_OVSR);
 373         writel_relaxed(BC_GANG_RESET, l3pmu->regs + L3_M_BC_GANG);
 374         writel_relaxed(BC_IRQCTL_RESET, l3pmu->regs + L3_M_BC_IRQCTL);
 375         writel_relaxed(PM_CR_RESET, l3pmu->regs + L3_HML3_PM_CR);
 376
 377         for (i = 0; i < L3_NUM_COUNTERS; ++i) {
 378                 writel_relaxed(PMCNT_RESET, l3pmu->regs + L3_HML3_PM_CNTCTL(i));
 379                 writel_relaxed(EVSEL(0), l3pmu->regs + L3_HML3_PM_EVTYPE(i));
 380         }
 381
 382         writel_relaxed(PM_FLTR_RESET, l3pmu->regs + L3_HML3_PM_FILTRA);
 383         writel_relaxed(PM_FLTR_RESET, l3pmu->regs + L3_HML3_PM_FILTRAM);
 384         writel_relaxed(PM_FLTR_RESET, l3pmu->regs + L3_HML3_PM_FILTRB);
 385         writel_relaxed(PM_FLTR_RESET, l3pmu->regs + L3_HML3_PM_FILTRBM);
 386         writel_relaxed(PM_FLTR_RESET, l3pmu->regs + L3_HML3_PM_FILTRC);
 387         writel_relaxed(PM_FLTR_RESET, l3pmu->regs + L3_HML3_PM_FILTRCM);
 388
 389         /*
 390          * Use writel here to ensure all programming commands are done
 391          *  before proceeding
 392          */
 393         writel(BC_ENABLE, l3pmu->regs + L3_M_BC_CR);
 394 }
 395
 396 static irqreturn_t qcom_l3_cache__handle_irq(int irq_num, void *data)
 397 {
 398         struct l3cache_pmu *l3pmu = data;
 399         /* Read the overflow status register */
 400         long status = readl_relaxed(l3pmu->regs + L3_M_BC_OVSR);
 401         int idx;
 402
 403         if (status == 0)
 404                 return IRQ_NONE;
 405
 406         /* Clear the bits we read on the overflow status register */
 407         writel_relaxed(status, l3pmu->regs + L3_M_BC_OVSR);
 408
 409         for_each_set_bit(idx, &status, L3_NUM_COUNTERS) {
 410                 struct perf_event *event;
 411                 const struct l3cache_event_ops *ops;
 412
 413                 event = l3pmu->events[idx];
 414                 if (!event)
 415                         continue;
 416
 417                 /*
 418                  * Since the IRQ is not enabled for events using long counters
 419                  * we should never see one of those here, however, be consistent
 420                  * and use the ops indirections like in the other operations.
 421                  */
 422
 423                 ops = l3cache_event_get_ops(event);
 424                 ops->update(event);
 425         }
 426
 427         return IRQ_HANDLED;
 428 }
 429
 430 /*
 431  * Implementation of abstract pmu functionality required by
 432  * the core perf events code.
 433  */
 434
 435 static void qcom_l3_cache__pmu_enable(struct pmu *pmu)
 436 {
 437         struct l3cache_pmu *l3pmu = to_l3cache_pmu(pmu);
 438
 439         /* Ensure the other programming commands are observed before enabling */
 440         wmb();
 441
 442         writel_relaxed(BC_ENABLE, l3pmu->regs + L3_M_BC_CR);
 443 }
 444
 445 static void qcom_l3_cache__pmu_disable(struct pmu *pmu)
 446 {
 447         struct l3cache_pmu *l3pmu = to_l3cache_pmu(pmu);
 448
 449         writel_relaxed(0, l3pmu->regs + L3_M_BC_CR);
 450
 451         /* Ensure the basic counter unit is stopped before proceeding */
 452         wmb();
 453 }
 454
 455 /*
 456  * We must NOT create groups containing events from multiple hardware PMUs,
 457  * although mixing different software and hardware PMUs is allowed.
 458  */
 459 static bool qcom_l3_cache__validate_event_group(struct perf_event *event)
 460 {
 461         struct perf_event *leader = event->group_leader;
 462         struct perf_event *sibling;
 463         int counters = 0;
 464
 465         if (leader->pmu != event->pmu && !is_software_event(leader))
 466                 return false;
 467
 468         counters = event_num_counters(event);
 469         counters += event_num_counters(leader);
 470
 471         for_each_sibling_event(sibling, leader) {
 472                 if (is_software_event(sibling))
 473                         continue;
 474                 if (sibling->pmu != event->pmu)
 475                         return false;
 476                 counters += event_num_counters(sibling);
 477         }
 478
 479         /*
 480          * If the group requires more counters than the HW has, it
 481          * cannot ever be scheduled.
 482          */
 483         return counters <= L3_NUM_COUNTERS;
 484 }
 485
 486 static int qcom_l3_cache__event_init(struct perf_event *event)
 487 {
 488         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 489         struct hw_perf_event *hwc = &event->hw;
 490
 491         /*
 492          * Is the event for this PMU?
 493          */
 494         if (event->attr.type != event->pmu->type)
 495                 return -ENOENT;
 496
 497         /*
 498          * There are no per-counter mode filters in the PMU.
 499          */
 500         if (event->attr.exclude_user || event->attr.exclude_kernel ||
 501             event->attr.exclude_hv || event->attr.exclude_idle)
 502                 return -EINVAL;
 503
 504         /*
 505          * Sampling not supported since these events are not core-attributable.
 506          */
 507         if (hwc->sample_period)
 508                 return -EINVAL;
 509
 510         /*
 511          * Task mode not available, we run the counters as socket counters,
 512          * not attributable to any CPU and therefore cannot attribute per-task.
 513          */
 514         if (event->cpu < 0)
 515                 return -EINVAL;
 516
 517         /* Validate the group */
 518         if (!qcom_l3_cache__validate_event_group(event))
 519                 return -EINVAL;
 520
 521         hwc->idx = -1;
 522
 523         /*
 524          * Many perf core operations (eg. events rotation) operate on a
 525          * single CPU context. This is obvious for CPU PMUs, where one
 526          * expects the same sets of events being observed on all CPUs,
 527          * but can lead to issues for off-core PMUs, like this one, where
 528          * each event could be theoretically assigned to a different CPU.
 529          * To mitigate this, we enforce CPU assignment to one designated
 530          * processor (the one described in the "cpumask" attribute exported
 531          * by the PMU device). perf user space tools honor this and avoid
 532          * opening more than one copy of the events.
 533          */
 534         event->cpu = cpumask_first(&l3pmu->cpumask);
 535
 536         return 0;
 537 }
 538
 539 static void qcom_l3_cache__event_start(struct perf_event *event, int flags)
 540 {
 541         struct hw_perf_event *hwc = &event->hw;
 542         const struct l3cache_event_ops *ops = l3cache_event_get_ops(event);
 543
 544         hwc->state = 0;
 545         ops->start(event);
 546 }
 547
 548 static void qcom_l3_cache__event_stop(struct perf_event *event, int flags)
 549 {
 550         struct hw_perf_event *hwc = &event->hw;
 551         const struct l3cache_event_ops *ops = l3cache_event_get_ops(event);
 552
 553         if (hwc->state & PERF_HES_STOPPED)
 554                 return;
 555
 556         ops->stop(event, flags);
 557         if (flags & PERF_EF_UPDATE)
 558                 ops->update(event);
 559         hwc->state |= PERF_HES_STOPPED | PERF_HES_UPTODATE;
 560 }
 561
 562 static int qcom_l3_cache__event_add(struct perf_event *event, int flags)
 563 {
 564         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 565         struct hw_perf_event *hwc = &event->hw;
 566         int order = event_uses_long_counter(event) ? 1 : 0;
 567         int idx;
 568
 569         /*
 570          * Try to allocate a counter.
 571          */
 572         idx = bitmap_find_free_region(l3pmu->used_mask, L3_NUM_COUNTERS, order);
 573         if (idx < 0)
 574                 /* The counters are all in use. */
 575                 return -EAGAIN;
 576
 577         hwc->idx = idx;
 578         hwc->state = PERF_HES_STOPPED | PERF_HES_UPTODATE;
 579         l3pmu->events[idx] = event;
 580
 581         if (flags & PERF_EF_START)
 582                 qcom_l3_cache__event_start(event, 0);
 583
 584         /* Propagate changes to the userspace mapping. */
 585         perf_event_update_userpage(event);
 586
 587         return 0;
 588 }
 589
 590 static void qcom_l3_cache__event_del(struct perf_event *event, int flags)
 591 {
 592         struct l3cache_pmu *l3pmu = to_l3cache_pmu(event->pmu);
 593         struct hw_perf_event *hwc = &event->hw;
 594         int order = event_uses_long_counter(event) ? 1 : 0;
 595
 596         /* Stop and clean up */
 597         qcom_l3_cache__event_stop(event,  flags | PERF_EF_UPDATE);
 598         l3pmu->events[hwc->idx] = NULL;
 599         bitmap_release_region(l3pmu->used_mask, hwc->idx, order);
 600
 601         /* Propagate changes to the userspace mapping. */
 602         perf_event_update_userpage(event);
 603 }
 604
 605 static void qcom_l3_cache__event_read(struct perf_event *event)
 606 {
 607         const struct l3cache_event_ops *ops = l3cache_event_get_ops(event);
 608
 609         ops->update(event);
 610 }
 611
 612 /*
 613  * Add sysfs attributes
 614  *
 615  * We export:
 616  * - formats, used by perf user space and other tools to configure events
 617  * - events, used by perf user space and other tools to create events
 618  *   symbolically, e.g.:
 619  *     perf stat -a -e l3cache_0_0/event=read-miss/ ls
 620  *     perf stat -a -e l3cache_0_0/event=0x21/ ls
 621  * - cpumask, used by perf user space and other tools to know on which CPUs
 622  *   to open the events
 623  */
 624
 625 /* formats */
 626
 627 static ssize_t l3cache_pmu_format_show(struct device *dev,
 628                                        struct device_attribute *attr, char *buf)
 629 {
 630         struct dev_ext_attribute *eattr;
 631
 632         eattr = container_of(attr, struct dev_ext_attribute, attr);
 633         return sprintf(buf, "%s\n", (char *) eattr->var);
 634 }
 635
 636 #define L3CACHE_PMU_FORMAT_ATTR(_name, _config)                               \
 637         (&((struct dev_ext_attribute[]) {                                     \
 638                 { .attr = __ATTR(_name, 0444, l3cache_pmu_format_show, NULL), \
 639                   .var = (void *) _config, }                                  \
 640         })[0].attr.attr)
 641
 642 static struct attribute *qcom_l3_cache_pmu_formats[] = {
 643         L3CACHE_PMU_FORMAT_ATTR(event, "config:0-7"),
 644         L3CACHE_PMU_FORMAT_ATTR(lc, "config:" __stringify(L3_EVENT_LC_BIT)),
 645         NULL,
 646 };
 647
 648 static struct attribute_group qcom_l3_cache_pmu_format_group = {
 649         .name = "format",
 650         .attrs = qcom_l3_cache_pmu_formats,
 651 };
 652
 653 /* events */
 654
 655 static ssize_t l3cache_pmu_event_show(struct device *dev,
 656                                      struct device_attribute *attr, char *page)
 657 {
 658         struct perf_pmu_events_attr *pmu_attr;
 659
 660         pmu_attr = container_of(attr, struct perf_pmu_events_attr, attr);
 661         return sprintf(page, "event=0x%02llx\n", pmu_attr->id);
 662 }
 663
 664 #define L3CACHE_EVENT_ATTR(_name, _id)                                       \
 665         (&((struct perf_pmu_events_attr[]) {                                 \
 666                 { .attr = __ATTR(_name, 0444, l3cache_pmu_event_show, NULL), \
 667                   .id = _id, }                                               \
 668         })[0].attr.attr)
 669
 670 static struct attribute *qcom_l3_cache_pmu_events[] = {
 671         L3CACHE_EVENT_ATTR(cycles, L3_EVENT_CYCLES),
 672         L3CACHE_EVENT_ATTR(read-hit, L3_EVENT_READ_HIT),
 673         L3CACHE_EVENT_ATTR(read-miss, L3_EVENT_READ_MISS),
 674         L3CACHE_EVENT_ATTR(read-hit-d-side, L3_EVENT_READ_HIT_D),
 675         L3CACHE_EVENT_ATTR(read-miss-d-side, L3_EVENT_READ_MISS_D),
 676         L3CACHE_EVENT_ATTR(write-hit, L3_EVENT_WRITE_HIT),
 677         L3CACHE_EVENT_ATTR(write-miss, L3_EVENT_WRITE_MISS),
 678         NULL
 679 };
 680
 681 static struct attribute_group qcom_l3_cache_pmu_events_group = {
 682         .name = "events",
 683         .attrs = qcom_l3_cache_pmu_events,
 684 };
 685
 686 /* cpumask */
 687
 688 static ssize_t qcom_l3_cache_pmu_cpumask_show(struct device *dev,
 689                                      struct device_attribute *attr, char *buf)
 690 {
 691         struct l3cache_pmu *l3pmu = to_l3cache_pmu(dev_get_drvdata(dev));
 692
 693         return cpumap_print_to_pagebuf(true, buf, &l3pmu->cpumask);
 694 }
 695
 696 static DEVICE_ATTR(cpumask, 0444, qcom_l3_cache_pmu_cpumask_show, NULL);
 697
 698 static struct attribute *qcom_l3_cache_pmu_cpumask_attrs[] = {
 699         &dev_attr_cpumask.attr,
 700         NULL,
 701 };
 702
 703 static struct attribute_group qcom_l3_cache_pmu_cpumask_attr_group = {
 704         .attrs = qcom_l3_cache_pmu_cpumask_attrs,
 705 };
 706
 707 /*
 708  * Per PMU device attribute groups
 709  */
 710 static const struct attribute_group *qcom_l3_cache_pmu_attr_grps[] = {
 711         &qcom_l3_cache_pmu_format_group,
 712         &qcom_l3_cache_pmu_events_group,
 713         &qcom_l3_cache_pmu_cpumask_attr_group,
 714         NULL,
 715 };
 716
 717 /*
 718  * Probing functions and data.
 719  */
 720
 721 static int qcom_l3_cache_pmu_online_cpu(unsigned int cpu, struct hlist_node *node)
 722 {
 723         struct l3cache_pmu *l3pmu = hlist_entry_safe(node, struct l3cache_pmu, node);
 724
 725         /* If there is not a CPU/PMU association pick this CPU */
 726         if (cpumask_empty(&l3pmu->cpumask))
 727                 cpumask_set_cpu(cpu, &l3pmu->cpumask);
 728
 729         return 0;
 730 }
 731
 732 static int qcom_l3_cache_pmu_offline_cpu(unsigned int cpu, struct hlist_node *node)
 733 {
 734         struct l3cache_pmu *l3pmu = hlist_entry_safe(node, struct l3cache_pmu, node);
 735         unsigned int target;
 736
 737         if (!cpumask_test_and_clear_cpu(cpu, &l3pmu->cpumask))
 738                 return 0;
 739         target = cpumask_any_but(cpu_online_mask, cpu);
 740         if (target >= nr_cpu_ids)
 741                 return 0;
 742         perf_pmu_migrate_context(&l3pmu->pmu, cpu, target);
 743         cpumask_set_cpu(target, &l3pmu->cpumask);
 744         return 0;
 745 }
 746
 747 static int qcom_l3_cache_pmu_probe(struct platform_device *pdev)
 748 {
 749         struct l3cache_pmu *l3pmu;
 750         struct acpi_device *acpi_dev;
 751         struct resource *memrc;
 752         int ret;
 753         char *name;
 754
 755         /* Initialize the PMU data structures */
 756
 757         acpi_dev = ACPI_COMPANION(&pdev->dev);
 758         if (!acpi_dev)
 759                 return -ENODEV;
 760
 761         l3pmu = devm_kzalloc(&pdev->dev, sizeof(*l3pmu), GFP_KERNEL);
 762         name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "l3cache_%s_%s",
 763                       acpi_dev->parent->pnp.unique_id, acpi_dev->pnp.unique_id);
 764         if (!l3pmu || !name)
 765                 return -ENOMEM;
 766
 767         l3pmu->pmu = (struct pmu) {
 768                 .task_ctx_nr    = perf_invalid_context,
 769
 770                 .pmu_enable     = qcom_l3_cache__pmu_enable,
 771                 .pmu_disable    = qcom_l3_cache__pmu_disable,
 772                 .event_init     = qcom_l3_cache__event_init,
 773                 .add            = qcom_l3_cache__event_add,
 774                 .del            = qcom_l3_cache__event_del,
 775                 .start          = qcom_l3_cache__event_start,
 776                 .stop           = qcom_l3_cache__event_stop,
 777                 .read           = qcom_l3_cache__event_read,
 778
 779                 .attr_groups    = qcom_l3_cache_pmu_attr_grps,
 780         };
 781
 782         memrc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 783         l3pmu->regs = devm_ioremap_resource(&pdev->dev, memrc);
 784         if (IS_ERR(l3pmu->regs)) {
 785                 dev_err(&pdev->dev, "Can't map PMU @%pa\n", &memrc->start);
 786                 return PTR_ERR(l3pmu->regs);
 787         }
 788
 789         qcom_l3_cache__init(l3pmu);
 790
 791         ret = platform_get_irq(pdev, 0);
 792         if (ret <= 0)
 793                 return ret;
 794
 795         ret = devm_request_irq(&pdev->dev, ret, qcom_l3_cache__handle_irq, 0,
 796                                name, l3pmu);
 797         if (ret) {
 798                 dev_err(&pdev->dev, "Request for IRQ failed for slice @%pa\n",
 799                         &memrc->start);
 800                 return ret;
 801         }
 802
 803         /* Add this instance to the list used by the offline callback */
 804         ret = cpuhp_state_add_instance(CPUHP_AP_PERF_ARM_QCOM_L3_ONLINE, &l3pmu->node);
 805         if (ret) {
 806                 dev_err(&pdev->dev, "Error %d registering hotplug", ret);
 807                 return ret;
 808         }
 809
 810         ret = perf_pmu_register(&l3pmu->pmu, name, -1);
 811         if (ret < 0) {
 812                 dev_err(&pdev->dev, "Failed to register L3 cache PMU (%d)\n", ret);
 813                 return ret;
 814         }
 815
 816         dev_info(&pdev->dev, "Registered %s, type: %d\n", name, l3pmu->pmu.type);
 817
 818         return 0;
 819 }
 820
 821 static const struct acpi_device_id qcom_l3_cache_pmu_acpi_match[] = {
 822         { "QCOM8081", },
 823         { }
 824 };
 825 MODULE_DEVICE_TABLE(acpi, qcom_l3_cache_pmu_acpi_match);
 826
 827 static struct platform_driver qcom_l3_cache_pmu_driver = {
 828         .driver = {
 829                 .name = "qcom-l3cache-pmu",
 830                 .acpi_match_table = ACPI_PTR(qcom_l3_cache_pmu_acpi_match),
 831         },
 832         .probe = qcom_l3_cache_pmu_probe,
 833 };
 834
 835 static int __init register_qcom_l3_cache_pmu_driver(void)
 836 {
 837         int ret;
 838
 839         /* Install a hook to update the reader CPU in case it goes offline */
 840         ret = cpuhp_setup_state_multi(CPUHP_AP_PERF_ARM_QCOM_L3_ONLINE,
 841                                       "perf/qcom/l3cache:online",
 842                                       qcom_l3_cache_pmu_online_cpu,
 843                                       qcom_l3_cache_pmu_offline_cpu);
 844         if (ret)
 845                 return ret;
 846
 847         return platform_driver_register(&qcom_l3_cache_pmu_driver);
 848 }
 849 device_initcall(register_qcom_l3_cache_pmu_driver);