GNU Linux-libre 4.19.304-gnu1
[releases.git] / 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);