drivers/perf/hisilicon/hisi_pcie_pmu.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * This driver adds support for PCIe PMU RCiEP device. Related
   4  * perf events are bandwidth, latency etc.
   5  *
   6  * Copyright (C) 2021 HiSilicon Limited
   7  * Author: Qi Liu <liuqi115@huawei.com>
   8  */
   9 #include <linux/bitfield.h>
  10 #include <linux/bitmap.h>
  11 #include <linux/bug.h>
  12 #include <linux/device.h>
  13 #include <linux/err.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/irq.h>
  16 #include <linux/kernel.h>
  17 #include <linux/list.h>
  18 #include <linux/module.h>
  19 #include <linux/pci.h>
  20 #include <linux/perf_event.h>
  21
  22 #define DRV_NAME "hisi_pcie_pmu"
  23 /* Define registers */
  24 #define HISI_PCIE_GLOBAL_CTRL           0x00
  25 #define HISI_PCIE_EVENT_CTRL            0x010
  26 #define HISI_PCIE_CNT                   0x090
  27 #define HISI_PCIE_EXT_CNT               0x110
  28 #define HISI_PCIE_INT_STAT              0x150
  29 #define HISI_PCIE_INT_MASK              0x154
  30 #define HISI_PCIE_REG_BDF               0xfe0
  31 #define HISI_PCIE_REG_VERSION           0xfe4
  32 #define HISI_PCIE_REG_INFO              0xfe8
  33
  34 /* Define command in HISI_PCIE_GLOBAL_CTRL */
  35 #define HISI_PCIE_GLOBAL_EN             0x01
  36 #define HISI_PCIE_GLOBAL_NONE           0
  37
  38 /* Define command in HISI_PCIE_EVENT_CTRL */
  39 #define HISI_PCIE_EVENT_EN              BIT_ULL(20)
  40 #define HISI_PCIE_RESET_CNT             BIT_ULL(22)
  41 #define HISI_PCIE_INIT_SET              BIT_ULL(34)
  42 #define HISI_PCIE_THR_EN                BIT_ULL(26)
  43 #define HISI_PCIE_TARGET_EN             BIT_ULL(32)
  44 #define HISI_PCIE_TRIG_EN               BIT_ULL(52)
  45
  46 /* Define offsets in HISI_PCIE_EVENT_CTRL */
  47 #define HISI_PCIE_EVENT_M               GENMASK_ULL(15, 0)
  48 #define HISI_PCIE_THR_MODE_M            GENMASK_ULL(27, 27)
  49 #define HISI_PCIE_THR_M                 GENMASK_ULL(31, 28)
  50 #define HISI_PCIE_TARGET_M              GENMASK_ULL(52, 36)
  51 #define HISI_PCIE_TRIG_MODE_M           GENMASK_ULL(53, 53)
  52 #define HISI_PCIE_TRIG_M                GENMASK_ULL(59, 56)
  53
  54 #define HISI_PCIE_MAX_COUNTERS          8
  55 #define HISI_PCIE_REG_STEP              8
  56 #define HISI_PCIE_THR_MAX_VAL           10
  57 #define HISI_PCIE_TRIG_MAX_VAL          10
  58 #define HISI_PCIE_MAX_PERIOD            (GENMASK_ULL(63, 0))
  59 #define HISI_PCIE_INIT_VAL              BIT_ULL(63)
  60
  61 struct hisi_pcie_pmu {
  62         struct perf_event *hw_events[HISI_PCIE_MAX_COUNTERS];
  63         struct hlist_node node;
  64         struct pci_dev *pdev;
  65         struct pmu pmu;
  66         void __iomem *base;
  67         int irq;
  68         u32 identifier;
  69         /* Minimum and maximum BDF of root ports monitored by PMU */
  70         u16 bdf_min;
  71         u16 bdf_max;
  72         int on_cpu;
  73 };
  74
  75 struct hisi_pcie_reg_pair {
  76         u16 lo;
  77         u16 hi;
  78 };
  79
  80 #define to_pcie_pmu(p)  (container_of((p), struct hisi_pcie_pmu, pmu))
  81 #define GET_PCI_DEVFN(bdf)  ((bdf) & 0xff)
  82
  83 #define HISI_PCIE_PMU_FILTER_ATTR(_name, _config, _hi, _lo)               \
  84         static u64 hisi_pcie_get_##_name(struct perf_event *event)        \
  85         {                                                                 \
  86                 return FIELD_GET(GENMASK(_hi, _lo), event->attr._config); \
  87         }                                                                 \
  88
  89 HISI_PCIE_PMU_FILTER_ATTR(event, config, 16, 0);
  90 HISI_PCIE_PMU_FILTER_ATTR(thr_len, config1, 3, 0);
  91 HISI_PCIE_PMU_FILTER_ATTR(thr_mode, config1, 4, 4);
  92 HISI_PCIE_PMU_FILTER_ATTR(trig_len, config1, 8, 5);
  93 HISI_PCIE_PMU_FILTER_ATTR(trig_mode, config1, 9, 9);
  94 HISI_PCIE_PMU_FILTER_ATTR(port, config2, 15, 0);
  95 HISI_PCIE_PMU_FILTER_ATTR(bdf, config2, 31, 16);
  96
  97 static ssize_t hisi_pcie_format_sysfs_show(struct device *dev, struct device_attribute *attr,
  98                                            char *buf)
  99 {
 100         struct dev_ext_attribute *eattr;
 101
 102         eattr = container_of(attr, struct dev_ext_attribute, attr);
 103
 104         return sysfs_emit(buf, "%s\n", (char *)eattr->var);
 105 }
 106
 107 static ssize_t hisi_pcie_event_sysfs_show(struct device *dev, struct device_attribute *attr,
 108                                           char *buf)
 109 {
 110         struct perf_pmu_events_attr *pmu_attr =
 111                 container_of(attr, struct perf_pmu_events_attr, attr);
 112
 113         return sysfs_emit(buf, "config=0x%llx\n", pmu_attr->id);
 114 }
 115
 116 #define HISI_PCIE_PMU_FORMAT_ATTR(_name, _format)                              \
 117         (&((struct dev_ext_attribute[]){                                       \
 118                 { .attr = __ATTR(_name, 0444, hisi_pcie_format_sysfs_show,     \
 119                                  NULL),                                        \
 120                   .var = (void *)_format }                                     \
 121         })[0].attr.attr)
 122
 123 #define HISI_PCIE_PMU_EVENT_ATTR(_name, _id)                    \
 124         PMU_EVENT_ATTR_ID(_name, hisi_pcie_event_sysfs_show, _id)
 125
 126 static ssize_t cpumask_show(struct device *dev, struct device_attribute *attr, char *buf)
 127 {
 128         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(dev_get_drvdata(dev));
 129
 130         return cpumap_print_to_pagebuf(true, buf, cpumask_of(pcie_pmu->on_cpu));
 131 }
 132 static DEVICE_ATTR_RO(cpumask);
 133
 134 static ssize_t identifier_show(struct device *dev, struct device_attribute *attr, char *buf)
 135 {
 136         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(dev_get_drvdata(dev));
 137
 138         return sysfs_emit(buf, "%#x\n", pcie_pmu->identifier);
 139 }
 140 static DEVICE_ATTR_RO(identifier);
 141
 142 static ssize_t bus_show(struct device *dev, struct device_attribute *attr, char *buf)
 143 {
 144         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(dev_get_drvdata(dev));
 145
 146         return sysfs_emit(buf, "%#04x\n", PCI_BUS_NUM(pcie_pmu->bdf_min));
 147 }
 148 static DEVICE_ATTR_RO(bus);
 149
 150 static struct hisi_pcie_reg_pair
 151 hisi_pcie_parse_reg_value(struct hisi_pcie_pmu *pcie_pmu, u32 reg_off)
 152 {
 153         u32 val = readl_relaxed(pcie_pmu->base + reg_off);
 154         struct hisi_pcie_reg_pair regs = {
 155                 .lo = val,
 156                 .hi = val >> 16,
 157         };
 158
 159         return regs;
 160 }
 161
 162 /*
 163  * Hardware counter and ext_counter work together for bandwidth, latency, bus
 164  * utilization and buffer occupancy events. For example, RX memory write latency
 165  * events(index = 0x0010), counter counts total delay cycles and ext_counter
 166  * counts RX memory write PCIe packets number.
 167  *
 168  * As we don't want PMU driver to process these two data, "delay cycles" can
 169  * be treated as an independent event(index = 0x0010), "RX memory write packets
 170  * number" as another(index = 0x10010). BIT 16 is used to distinguish and 0-15
 171  * bits are "real" event index, which can be used to set HISI_PCIE_EVENT_CTRL.
 172  */
 173 #define EXT_COUNTER_IS_USED(idx)                ((idx) & BIT(16))
 174
 175 static u32 hisi_pcie_get_real_event(struct perf_event *event)
 176 {
 177         return hisi_pcie_get_event(event) & GENMASK(15, 0);
 178 }
 179
 180 static u32 hisi_pcie_pmu_get_offset(u32 offset, u32 idx)
 181 {
 182         return offset + HISI_PCIE_REG_STEP * idx;
 183 }
 184
 185 static u32 hisi_pcie_pmu_readl(struct hisi_pcie_pmu *pcie_pmu, u32 reg_offset,
 186                                u32 idx)
 187 {
 188         u32 offset = hisi_pcie_pmu_get_offset(reg_offset, idx);
 189
 190         return readl_relaxed(pcie_pmu->base + offset);
 191 }
 192
 193 static void hisi_pcie_pmu_writel(struct hisi_pcie_pmu *pcie_pmu, u32 reg_offset, u32 idx, u32 val)
 194 {
 195         u32 offset = hisi_pcie_pmu_get_offset(reg_offset, idx);
 196
 197         writel_relaxed(val, pcie_pmu->base + offset);
 198 }
 199
 200 static u64 hisi_pcie_pmu_readq(struct hisi_pcie_pmu *pcie_pmu, u32 reg_offset, u32 idx)
 201 {
 202         u32 offset = hisi_pcie_pmu_get_offset(reg_offset, idx);
 203
 204         return readq_relaxed(pcie_pmu->base + offset);
 205 }
 206
 207 static void hisi_pcie_pmu_writeq(struct hisi_pcie_pmu *pcie_pmu, u32 reg_offset, u32 idx, u64 val)
 208 {
 209         u32 offset = hisi_pcie_pmu_get_offset(reg_offset, idx);
 210
 211         writeq_relaxed(val, pcie_pmu->base + offset);
 212 }
 213
 214 static void hisi_pcie_pmu_config_filter(struct perf_event *event)
 215 {
 216         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 217         struct hw_perf_event *hwc = &event->hw;
 218         u64 reg = HISI_PCIE_INIT_SET;
 219         u64 port, trig_len, thr_len;
 220
 221         /* Config HISI_PCIE_EVENT_CTRL according to event. */
 222         reg |= FIELD_PREP(HISI_PCIE_EVENT_M, hisi_pcie_get_real_event(event));
 223
 224         /* Config HISI_PCIE_EVENT_CTRL according to root port or EP device. */
 225         port = hisi_pcie_get_port(event);
 226         if (port)
 227                 reg |= FIELD_PREP(HISI_PCIE_TARGET_M, port);
 228         else
 229                 reg |= HISI_PCIE_TARGET_EN |
 230                        FIELD_PREP(HISI_PCIE_TARGET_M, hisi_pcie_get_bdf(event));
 231
 232         /* Config HISI_PCIE_EVENT_CTRL according to trigger condition. */
 233         trig_len = hisi_pcie_get_trig_len(event);
 234         if (trig_len) {
 235                 reg |= FIELD_PREP(HISI_PCIE_TRIG_M, trig_len);
 236                 reg |= FIELD_PREP(HISI_PCIE_TRIG_MODE_M, hisi_pcie_get_trig_mode(event));
 237                 reg |= HISI_PCIE_TRIG_EN;
 238         }
 239
 240         /* Config HISI_PCIE_EVENT_CTRL according to threshold condition. */
 241         thr_len = hisi_pcie_get_thr_len(event);
 242         if (thr_len) {
 243                 reg |= FIELD_PREP(HISI_PCIE_THR_M, thr_len);
 244                 reg |= FIELD_PREP(HISI_PCIE_THR_MODE_M, hisi_pcie_get_thr_mode(event));
 245                 reg |= HISI_PCIE_THR_EN;
 246         }
 247
 248         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_EVENT_CTRL, hwc->idx, reg);
 249 }
 250
 251 static void hisi_pcie_pmu_clear_filter(struct perf_event *event)
 252 {
 253         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 254         struct hw_perf_event *hwc = &event->hw;
 255
 256         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_EVENT_CTRL, hwc->idx, HISI_PCIE_INIT_SET);
 257 }
 258
 259 static bool hisi_pcie_pmu_valid_requester_id(struct hisi_pcie_pmu *pcie_pmu, u32 bdf)
 260 {
 261         struct pci_dev *root_port, *pdev;
 262         u16 rp_bdf;
 263
 264         pdev = pci_get_domain_bus_and_slot(pci_domain_nr(pcie_pmu->pdev->bus), PCI_BUS_NUM(bdf),
 265                                            GET_PCI_DEVFN(bdf));
 266         if (!pdev)
 267                 return false;
 268
 269         root_port = pcie_find_root_port(pdev);
 270         if (!root_port) {
 271                 pci_dev_put(pdev);
 272                 return false;
 273         }
 274
 275         pci_dev_put(pdev);
 276         rp_bdf = pci_dev_id(root_port);
 277         return rp_bdf >= pcie_pmu->bdf_min && rp_bdf <= pcie_pmu->bdf_max;
 278 }
 279
 280 static bool hisi_pcie_pmu_valid_filter(struct perf_event *event,
 281                                        struct hisi_pcie_pmu *pcie_pmu)
 282 {
 283         u32 requester_id = hisi_pcie_get_bdf(event);
 284
 285         if (hisi_pcie_get_thr_len(event) > HISI_PCIE_THR_MAX_VAL)
 286                 return false;
 287
 288         if (hisi_pcie_get_trig_len(event) > HISI_PCIE_TRIG_MAX_VAL)
 289                 return false;
 290
 291         if (requester_id) {
 292                 if (!hisi_pcie_pmu_valid_requester_id(pcie_pmu, requester_id))
 293                         return false;
 294         }
 295
 296         return true;
 297 }
 298
 299 static bool hisi_pcie_pmu_cmp_event(struct perf_event *target,
 300                                         struct perf_event *event)
 301 {
 302         return hisi_pcie_get_real_event(target) == hisi_pcie_get_real_event(event);
 303 }
 304
 305 static bool hisi_pcie_pmu_validate_event_group(struct perf_event *event)
 306 {
 307         struct perf_event *sibling, *leader = event->group_leader;
 308         struct perf_event *event_group[HISI_PCIE_MAX_COUNTERS];
 309         int counters = 1;
 310         int num;
 311
 312         event_group[0] = leader;
 313         if (!is_software_event(leader)) {
 314                 if (leader->pmu != event->pmu)
 315                         return false;
 316
 317                 if (leader != event && !hisi_pcie_pmu_cmp_event(leader, event))
 318                         event_group[counters++] = event;
 319         }
 320
 321         for_each_sibling_event(sibling, event->group_leader) {
 322                 if (is_software_event(sibling))
 323                         continue;
 324
 325                 if (sibling->pmu != event->pmu)
 326                         return false;
 327
 328                 for (num = 0; num < counters; num++) {
 329                         if (hisi_pcie_pmu_cmp_event(event_group[num], sibling))
 330                                 break;
 331                 }
 332
 333                 if (num == counters)
 334                         event_group[counters++] = sibling;
 335         }
 336
 337         return counters <= HISI_PCIE_MAX_COUNTERS;
 338 }
 339
 340 static int hisi_pcie_pmu_event_init(struct perf_event *event)
 341 {
 342         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 343         struct hw_perf_event *hwc = &event->hw;
 344
 345         event->cpu = pcie_pmu->on_cpu;
 346
 347         if (EXT_COUNTER_IS_USED(hisi_pcie_get_event(event)))
 348                 hwc->event_base = HISI_PCIE_EXT_CNT;
 349         else
 350                 hwc->event_base = HISI_PCIE_CNT;
 351
 352         if (event->attr.type != event->pmu->type)
 353                 return -ENOENT;
 354
 355         /* Sampling is not supported. */
 356         if (is_sampling_event(event) || event->attach_state & PERF_ATTACH_TASK)
 357                 return -EOPNOTSUPP;
 358
 359         if (!hisi_pcie_pmu_valid_filter(event, pcie_pmu))
 360                 return -EINVAL;
 361
 362         if (!hisi_pcie_pmu_validate_event_group(event))
 363                 return -EINVAL;
 364
 365         return 0;
 366 }
 367
 368 static u64 hisi_pcie_pmu_read_counter(struct perf_event *event)
 369 {
 370         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 371         u32 idx = event->hw.idx;
 372
 373         return hisi_pcie_pmu_readq(pcie_pmu, event->hw.event_base, idx);
 374 }
 375
 376 static int hisi_pcie_pmu_find_related_event(struct hisi_pcie_pmu *pcie_pmu,
 377                                             struct perf_event *event)
 378 {
 379         struct perf_event *sibling;
 380         int idx;
 381
 382         for (idx = 0; idx < HISI_PCIE_MAX_COUNTERS; idx++) {
 383                 sibling = pcie_pmu->hw_events[idx];
 384                 if (!sibling)
 385                         continue;
 386
 387                 if (!hisi_pcie_pmu_cmp_event(sibling, event))
 388                         continue;
 389
 390                 /* Related events must be used in group */
 391                 if (sibling->group_leader == event->group_leader)
 392                         return idx;
 393                 else
 394                         return -EINVAL;
 395         }
 396
 397         return idx;
 398 }
 399
 400 static int hisi_pcie_pmu_get_event_idx(struct hisi_pcie_pmu *pcie_pmu)
 401 {
 402         int idx;
 403
 404         for (idx = 0; idx < HISI_PCIE_MAX_COUNTERS; idx++) {
 405                 if (!pcie_pmu->hw_events[idx])
 406                         return idx;
 407         }
 408
 409         return -EINVAL;
 410 }
 411
 412 static void hisi_pcie_pmu_event_update(struct perf_event *event)
 413 {
 414         struct hw_perf_event *hwc = &event->hw;
 415         u64 new_cnt, prev_cnt, delta;
 416
 417         do {
 418                 prev_cnt = local64_read(&hwc->prev_count);
 419                 new_cnt = hisi_pcie_pmu_read_counter(event);
 420         } while (local64_cmpxchg(&hwc->prev_count, prev_cnt,
 421                                  new_cnt) != prev_cnt);
 422
 423         delta = (new_cnt - prev_cnt) & HISI_PCIE_MAX_PERIOD;
 424         local64_add(delta, &event->count);
 425 }
 426
 427 static void hisi_pcie_pmu_read(struct perf_event *event)
 428 {
 429         hisi_pcie_pmu_event_update(event);
 430 }
 431
 432 static void hisi_pcie_pmu_set_period(struct perf_event *event)
 433 {
 434         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 435         struct hw_perf_event *hwc = &event->hw;
 436         int idx = hwc->idx;
 437
 438         local64_set(&hwc->prev_count, HISI_PCIE_INIT_VAL);
 439         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_CNT, idx, HISI_PCIE_INIT_VAL);
 440         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_EXT_CNT, idx, HISI_PCIE_INIT_VAL);
 441 }
 442
 443 static void hisi_pcie_pmu_enable_counter(struct hisi_pcie_pmu *pcie_pmu, struct hw_perf_event *hwc)
 444 {
 445         u32 idx = hwc->idx;
 446         u64 val;
 447
 448         val = hisi_pcie_pmu_readq(pcie_pmu, HISI_PCIE_EVENT_CTRL, idx);
 449         val |= HISI_PCIE_EVENT_EN;
 450         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_EVENT_CTRL, idx, val);
 451 }
 452
 453 static void hisi_pcie_pmu_disable_counter(struct hisi_pcie_pmu *pcie_pmu, struct hw_perf_event *hwc)
 454 {
 455         u32 idx = hwc->idx;
 456         u64 val;
 457
 458         val = hisi_pcie_pmu_readq(pcie_pmu, HISI_PCIE_EVENT_CTRL, idx);
 459         val &= ~HISI_PCIE_EVENT_EN;
 460         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_EVENT_CTRL, idx, val);
 461 }
 462
 463 static void hisi_pcie_pmu_enable_int(struct hisi_pcie_pmu *pcie_pmu, struct hw_perf_event *hwc)
 464 {
 465         u32 idx = hwc->idx;
 466
 467         hisi_pcie_pmu_writel(pcie_pmu, HISI_PCIE_INT_MASK, idx, 0);
 468 }
 469
 470 static void hisi_pcie_pmu_disable_int(struct hisi_pcie_pmu *pcie_pmu, struct hw_perf_event *hwc)
 471 {
 472         u32 idx = hwc->idx;
 473
 474         hisi_pcie_pmu_writel(pcie_pmu, HISI_PCIE_INT_MASK, idx, 1);
 475 }
 476
 477 static void hisi_pcie_pmu_reset_counter(struct hisi_pcie_pmu *pcie_pmu, int idx)
 478 {
 479         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_EVENT_CTRL, idx, HISI_PCIE_RESET_CNT);
 480         hisi_pcie_pmu_writeq(pcie_pmu, HISI_PCIE_EVENT_CTRL, idx, HISI_PCIE_INIT_SET);
 481 }
 482
 483 static void hisi_pcie_pmu_start(struct perf_event *event, int flags)
 484 {
 485         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 486         struct hw_perf_event *hwc = &event->hw;
 487         int idx = hwc->idx;
 488         u64 prev_cnt;
 489
 490         if (WARN_ON_ONCE(!(hwc->state & PERF_HES_STOPPED)))
 491                 return;
 492
 493         WARN_ON_ONCE(!(hwc->state & PERF_HES_UPTODATE));
 494         hwc->state = 0;
 495
 496         hisi_pcie_pmu_config_filter(event);
 497         hisi_pcie_pmu_enable_counter(pcie_pmu, hwc);
 498         hisi_pcie_pmu_enable_int(pcie_pmu, hwc);
 499         hisi_pcie_pmu_set_period(event);
 500
 501         if (flags & PERF_EF_RELOAD) {
 502                 prev_cnt = local64_read(&hwc->prev_count);
 503                 hisi_pcie_pmu_writeq(pcie_pmu, hwc->event_base, idx, prev_cnt);
 504         }
 505
 506         perf_event_update_userpage(event);
 507 }
 508
 509 static void hisi_pcie_pmu_stop(struct perf_event *event, int flags)
 510 {
 511         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 512         struct hw_perf_event *hwc = &event->hw;
 513
 514         hisi_pcie_pmu_event_update(event);
 515         hisi_pcie_pmu_disable_int(pcie_pmu, hwc);
 516         hisi_pcie_pmu_disable_counter(pcie_pmu, hwc);
 517         hisi_pcie_pmu_clear_filter(event);
 518         WARN_ON_ONCE(hwc->state & PERF_HES_STOPPED);
 519         hwc->state |= PERF_HES_STOPPED;
 520
 521         if (hwc->state & PERF_HES_UPTODATE)
 522                 return;
 523
 524         hwc->state |= PERF_HES_UPTODATE;
 525 }
 526
 527 static int hisi_pcie_pmu_add(struct perf_event *event, int flags)
 528 {
 529         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 530         struct hw_perf_event *hwc = &event->hw;
 531         int idx;
 532
 533         hwc->state = PERF_HES_STOPPED | PERF_HES_UPTODATE;
 534
 535         /* Check all working events to find a related event. */
 536         idx = hisi_pcie_pmu_find_related_event(pcie_pmu, event);
 537         if (idx < 0)
 538                 return idx;
 539
 540         /* Current event shares an enabled counter with the related event */
 541         if (idx < HISI_PCIE_MAX_COUNTERS) {
 542                 hwc->idx = idx;
 543                 goto start_count;
 544         }
 545
 546         idx = hisi_pcie_pmu_get_event_idx(pcie_pmu);
 547         if (idx < 0)
 548                 return idx;
 549
 550         hwc->idx = idx;
 551         pcie_pmu->hw_events[idx] = event;
 552         /* Reset Counter to avoid previous statistic interference. */
 553         hisi_pcie_pmu_reset_counter(pcie_pmu, idx);
 554
 555 start_count:
 556         if (flags & PERF_EF_START)
 557                 hisi_pcie_pmu_start(event, PERF_EF_RELOAD);
 558
 559         return 0;
 560 }
 561
 562 static void hisi_pcie_pmu_del(struct perf_event *event, int flags)
 563 {
 564         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(event->pmu);
 565         struct hw_perf_event *hwc = &event->hw;
 566
 567         hisi_pcie_pmu_stop(event, PERF_EF_UPDATE);
 568         pcie_pmu->hw_events[hwc->idx] = NULL;
 569         perf_event_update_userpage(event);
 570 }
 571
 572 static void hisi_pcie_pmu_enable(struct pmu *pmu)
 573 {
 574         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(pmu);
 575         int num;
 576
 577         for (num = 0; num < HISI_PCIE_MAX_COUNTERS; num++) {
 578                 if (pcie_pmu->hw_events[num])
 579                         break;
 580         }
 581
 582         if (num == HISI_PCIE_MAX_COUNTERS)
 583                 return;
 584
 585         writel(HISI_PCIE_GLOBAL_EN, pcie_pmu->base + HISI_PCIE_GLOBAL_CTRL);
 586 }
 587
 588 static void hisi_pcie_pmu_disable(struct pmu *pmu)
 589 {
 590         struct hisi_pcie_pmu *pcie_pmu = to_pcie_pmu(pmu);
 591
 592         writel(HISI_PCIE_GLOBAL_NONE, pcie_pmu->base + HISI_PCIE_GLOBAL_CTRL);
 593 }
 594
 595 static irqreturn_t hisi_pcie_pmu_irq(int irq, void *data)
 596 {
 597         struct hisi_pcie_pmu *pcie_pmu = data;
 598         irqreturn_t ret = IRQ_NONE;
 599         struct perf_event *event;
 600         u32 overflown;
 601         int idx;
 602
 603         for (idx = 0; idx < HISI_PCIE_MAX_COUNTERS; idx++) {
 604                 overflown = hisi_pcie_pmu_readl(pcie_pmu, HISI_PCIE_INT_STAT, idx);
 605                 if (!overflown)
 606                         continue;
 607
 608                 /* Clear status of interrupt. */
 609                 hisi_pcie_pmu_writel(pcie_pmu, HISI_PCIE_INT_STAT, idx, 1);
 610                 event = pcie_pmu->hw_events[idx];
 611                 if (!event)
 612                         continue;
 613
 614                 hisi_pcie_pmu_event_update(event);
 615                 hisi_pcie_pmu_set_period(event);
 616                 ret = IRQ_HANDLED;
 617         }
 618
 619         return ret;
 620 }
 621
 622 static int hisi_pcie_pmu_irq_register(struct pci_dev *pdev, struct hisi_pcie_pmu *pcie_pmu)
 623 {
 624         int irq, ret;
 625
 626         ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
 627         if (ret < 0) {
 628                 pci_err(pdev, "Failed to enable MSI vectors: %d\n", ret);
 629                 return ret;
 630         }
 631
 632         irq = pci_irq_vector(pdev, 0);
 633         ret = request_irq(irq, hisi_pcie_pmu_irq, IRQF_NOBALANCING | IRQF_NO_THREAD, DRV_NAME,
 634                           pcie_pmu);
 635         if (ret) {
 636                 pci_err(pdev, "Failed to register IRQ: %d\n", ret);
 637                 pci_free_irq_vectors(pdev);
 638                 return ret;
 639         }
 640
 641         pcie_pmu->irq = irq;
 642
 643         return 0;
 644 }
 645
 646 static void hisi_pcie_pmu_irq_unregister(struct pci_dev *pdev, struct hisi_pcie_pmu *pcie_pmu)
 647 {
 648         free_irq(pcie_pmu->irq, pcie_pmu);
 649         pci_free_irq_vectors(pdev);
 650 }
 651
 652 static int hisi_pcie_pmu_online_cpu(unsigned int cpu, struct hlist_node *node)
 653 {
 654         struct hisi_pcie_pmu *pcie_pmu = hlist_entry_safe(node, struct hisi_pcie_pmu, node);
 655
 656         if (pcie_pmu->on_cpu == -1) {
 657                 pcie_pmu->on_cpu = cpu;
 658                 WARN_ON(irq_set_affinity(pcie_pmu->irq, cpumask_of(cpu)));
 659         }
 660
 661         return 0;
 662 }
 663
 664 static int hisi_pcie_pmu_offline_cpu(unsigned int cpu, struct hlist_node *node)
 665 {
 666         struct hisi_pcie_pmu *pcie_pmu = hlist_entry_safe(node, struct hisi_pcie_pmu, node);
 667         unsigned int target;
 668
 669         /* Nothing to do if this CPU doesn't own the PMU */
 670         if (pcie_pmu->on_cpu != cpu)
 671                 return 0;
 672
 673         pcie_pmu->on_cpu = -1;
 674         /* Choose a new CPU from all online cpus. */
 675         target = cpumask_first(cpu_online_mask);
 676         if (target >= nr_cpu_ids) {
 677                 pci_err(pcie_pmu->pdev, "There is no CPU to set\n");
 678                 return 0;
 679         }
 680
 681         perf_pmu_migrate_context(&pcie_pmu->pmu, cpu, target);
 682         /* Use this CPU for event counting */
 683         pcie_pmu->on_cpu = target;
 684         WARN_ON(irq_set_affinity(pcie_pmu->irq, cpumask_of(target)));
 685
 686         return 0;
 687 }
 688
 689 static struct attribute *hisi_pcie_pmu_events_attr[] = {
 690         HISI_PCIE_PMU_EVENT_ATTR(rx_mwr_latency, 0x0010),
 691         HISI_PCIE_PMU_EVENT_ATTR(rx_mwr_cnt, 0x10010),
 692         HISI_PCIE_PMU_EVENT_ATTR(rx_mrd_latency, 0x0210),
 693         HISI_PCIE_PMU_EVENT_ATTR(rx_mrd_cnt, 0x10210),
 694         HISI_PCIE_PMU_EVENT_ATTR(tx_mrd_latency, 0x0011),
 695         HISI_PCIE_PMU_EVENT_ATTR(tx_mrd_cnt, 0x10011),
 696         HISI_PCIE_PMU_EVENT_ATTR(rx_mrd_flux, 0x1005),
 697         HISI_PCIE_PMU_EVENT_ATTR(rx_mrd_time, 0x11005),
 698         HISI_PCIE_PMU_EVENT_ATTR(tx_mrd_flux, 0x2004),
 699         HISI_PCIE_PMU_EVENT_ATTR(tx_mrd_time, 0x12004),
 700         NULL
 701 };
 702
 703 static struct attribute_group hisi_pcie_pmu_events_group = {
 704         .name = "events",
 705         .attrs = hisi_pcie_pmu_events_attr,
 706 };
 707
 708 static struct attribute *hisi_pcie_pmu_format_attr[] = {
 709         HISI_PCIE_PMU_FORMAT_ATTR(event, "config:0-16"),
 710         HISI_PCIE_PMU_FORMAT_ATTR(thr_len, "config1:0-3"),
 711         HISI_PCIE_PMU_FORMAT_ATTR(thr_mode, "config1:4"),
 712         HISI_PCIE_PMU_FORMAT_ATTR(trig_len, "config1:5-8"),
 713         HISI_PCIE_PMU_FORMAT_ATTR(trig_mode, "config1:9"),
 714         HISI_PCIE_PMU_FORMAT_ATTR(port, "config2:0-15"),
 715         HISI_PCIE_PMU_FORMAT_ATTR(bdf, "config2:16-31"),
 716         NULL
 717 };
 718
 719 static const struct attribute_group hisi_pcie_pmu_format_group = {
 720         .name = "format",
 721         .attrs = hisi_pcie_pmu_format_attr,
 722 };
 723
 724 static struct attribute *hisi_pcie_pmu_bus_attrs[] = {
 725         &dev_attr_bus.attr,
 726         NULL
 727 };
 728
 729 static const struct attribute_group hisi_pcie_pmu_bus_attr_group = {
 730         .attrs = hisi_pcie_pmu_bus_attrs,
 731 };
 732
 733 static struct attribute *hisi_pcie_pmu_cpumask_attrs[] = {
 734         &dev_attr_cpumask.attr,
 735         NULL
 736 };
 737
 738 static const struct attribute_group hisi_pcie_pmu_cpumask_attr_group = {
 739         .attrs = hisi_pcie_pmu_cpumask_attrs,
 740 };
 741
 742 static struct attribute *hisi_pcie_pmu_identifier_attrs[] = {
 743         &dev_attr_identifier.attr,
 744         NULL
 745 };
 746
 747 static const struct attribute_group hisi_pcie_pmu_identifier_attr_group = {
 748         .attrs = hisi_pcie_pmu_identifier_attrs,
 749 };
 750
 751 static const struct attribute_group *hisi_pcie_pmu_attr_groups[] = {
 752         &hisi_pcie_pmu_events_group,
 753         &hisi_pcie_pmu_format_group,
 754         &hisi_pcie_pmu_bus_attr_group,
 755         &hisi_pcie_pmu_cpumask_attr_group,
 756         &hisi_pcie_pmu_identifier_attr_group,
 757         NULL
 758 };
 759
 760 static int hisi_pcie_alloc_pmu(struct pci_dev *pdev, struct hisi_pcie_pmu *pcie_pmu)
 761 {
 762         struct hisi_pcie_reg_pair regs;
 763         u16 sicl_id, core_id;
 764         char *name;
 765
 766         regs = hisi_pcie_parse_reg_value(pcie_pmu, HISI_PCIE_REG_BDF);
 767         pcie_pmu->bdf_min = regs.lo;
 768         pcie_pmu->bdf_max = regs.hi;
 769
 770         regs = hisi_pcie_parse_reg_value(pcie_pmu, HISI_PCIE_REG_INFO);
 771         sicl_id = regs.hi;
 772         core_id = regs.lo;
 773
 774         name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "hisi_pcie%u_core%u", sicl_id, core_id);
 775         if (!name)
 776                 return -ENOMEM;
 777
 778         pcie_pmu->pdev = pdev;
 779         pcie_pmu->on_cpu = -1;
 780         pcie_pmu->identifier = readl(pcie_pmu->base + HISI_PCIE_REG_VERSION);
 781         pcie_pmu->pmu = (struct pmu) {
 782                 .name           = name,
 783                 .module         = THIS_MODULE,
 784                 .event_init     = hisi_pcie_pmu_event_init,
 785                 .pmu_enable     = hisi_pcie_pmu_enable,
 786                 .pmu_disable    = hisi_pcie_pmu_disable,
 787                 .add            = hisi_pcie_pmu_add,
 788                 .del            = hisi_pcie_pmu_del,
 789                 .start          = hisi_pcie_pmu_start,
 790                 .stop           = hisi_pcie_pmu_stop,
 791                 .read           = hisi_pcie_pmu_read,
 792                 .task_ctx_nr    = perf_invalid_context,
 793                 .attr_groups    = hisi_pcie_pmu_attr_groups,
 794                 .capabilities   = PERF_PMU_CAP_NO_EXCLUDE,
 795         };
 796
 797         return 0;
 798 }
 799
 800 static int hisi_pcie_init_pmu(struct pci_dev *pdev, struct hisi_pcie_pmu *pcie_pmu)
 801 {
 802         int ret;
 803
 804         pcie_pmu->base = pci_ioremap_bar(pdev, 2);
 805         if (!pcie_pmu->base) {
 806                 pci_err(pdev, "Ioremap failed for pcie_pmu resource\n");
 807                 return -ENOMEM;
 808         }
 809
 810         ret = hisi_pcie_alloc_pmu(pdev, pcie_pmu);
 811         if (ret)
 812                 goto err_iounmap;
 813
 814         ret = hisi_pcie_pmu_irq_register(pdev, pcie_pmu);
 815         if (ret)
 816                 goto err_iounmap;
 817
 818         ret = cpuhp_state_add_instance(CPUHP_AP_PERF_ARM_HISI_PCIE_PMU_ONLINE, &pcie_pmu->node);
 819         if (ret) {
 820                 pci_err(pdev, "Failed to register hotplug: %d\n", ret);
 821                 goto err_irq_unregister;
 822         }
 823
 824         ret = perf_pmu_register(&pcie_pmu->pmu, pcie_pmu->pmu.name, -1);
 825         if (ret) {
 826                 pci_err(pdev, "Failed to register PCIe PMU: %d\n", ret);
 827                 goto err_hotplug_unregister;
 828         }
 829
 830         return ret;
 831
 832 err_hotplug_unregister:
 833         cpuhp_state_remove_instance_nocalls(
 834                 CPUHP_AP_PERF_ARM_HISI_PCIE_PMU_ONLINE, &pcie_pmu->node);
 835
 836 err_irq_unregister:
 837         hisi_pcie_pmu_irq_unregister(pdev, pcie_pmu);
 838
 839 err_iounmap:
 840         iounmap(pcie_pmu->base);
 841
 842         return ret;
 843 }
 844
 845 static void hisi_pcie_uninit_pmu(struct pci_dev *pdev)
 846 {
 847         struct hisi_pcie_pmu *pcie_pmu = pci_get_drvdata(pdev);
 848
 849         perf_pmu_unregister(&pcie_pmu->pmu);
 850         cpuhp_state_remove_instance_nocalls(
 851                 CPUHP_AP_PERF_ARM_HISI_PCIE_PMU_ONLINE, &pcie_pmu->node);
 852         hisi_pcie_pmu_irq_unregister(pdev, pcie_pmu);
 853         iounmap(pcie_pmu->base);
 854 }
 855
 856 static int hisi_pcie_init_dev(struct pci_dev *pdev)
 857 {
 858         int ret;
 859
 860         ret = pcim_enable_device(pdev);
 861         if (ret) {
 862                 pci_err(pdev, "Failed to enable PCI device: %d\n", ret);
 863                 return ret;
 864         }
 865
 866         ret = pcim_iomap_regions(pdev, BIT(2), DRV_NAME);
 867         if (ret < 0) {
 868                 pci_err(pdev, "Failed to request PCI mem regions: %d\n", ret);
 869                 return ret;
 870         }
 871
 872         pci_set_master(pdev);
 873
 874         return 0;
 875 }
 876
 877 static int hisi_pcie_pmu_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 878 {
 879         struct hisi_pcie_pmu *pcie_pmu;
 880         int ret;
 881
 882         pcie_pmu = devm_kzalloc(&pdev->dev, sizeof(*pcie_pmu), GFP_KERNEL);
 883         if (!pcie_pmu)
 884                 return -ENOMEM;
 885
 886         ret = hisi_pcie_init_dev(pdev);
 887         if (ret)
 888                 return ret;
 889
 890         ret = hisi_pcie_init_pmu(pdev, pcie_pmu);
 891         if (ret)
 892                 return ret;
 893
 894         pci_set_drvdata(pdev, pcie_pmu);
 895
 896         return ret;
 897 }
 898
 899 static void hisi_pcie_pmu_remove(struct pci_dev *pdev)
 900 {
 901         hisi_pcie_uninit_pmu(pdev);
 902         pci_set_drvdata(pdev, NULL);
 903 }
 904
 905 static const struct pci_device_id hisi_pcie_pmu_ids[] = {
 906         { PCI_DEVICE(PCI_VENDOR_ID_HUAWEI, 0xa12d) },
 907         { 0, }
 908 };
 909 MODULE_DEVICE_TABLE(pci, hisi_pcie_pmu_ids);
 910
 911 static struct pci_driver hisi_pcie_pmu_driver = {
 912         .name = DRV_NAME,
 913         .id_table = hisi_pcie_pmu_ids,
 914         .probe = hisi_pcie_pmu_probe,
 915         .remove = hisi_pcie_pmu_remove,
 916 };
 917
 918 static int __init hisi_pcie_module_init(void)
 919 {
 920         int ret;
 921
 922         ret = cpuhp_setup_state_multi(CPUHP_AP_PERF_ARM_HISI_PCIE_PMU_ONLINE,
 923                                       "AP_PERF_ARM_HISI_PCIE_PMU_ONLINE",
 924                                       hisi_pcie_pmu_online_cpu,
 925                                       hisi_pcie_pmu_offline_cpu);
 926         if (ret) {
 927                 pr_err("Failed to setup PCIe PMU hotplug: %d\n", ret);
 928                 return ret;
 929         }
 930
 931         ret = pci_register_driver(&hisi_pcie_pmu_driver);
 932         if (ret)
 933                 cpuhp_remove_multi_state(CPUHP_AP_PERF_ARM_HISI_PCIE_PMU_ONLINE);
 934
 935         return ret;
 936 }
 937 module_init(hisi_pcie_module_init);
 938
 939 static void __exit hisi_pcie_module_exit(void)
 940 {
 941         pci_unregister_driver(&hisi_pcie_pmu_driver);
 942         cpuhp_remove_multi_state(CPUHP_AP_PERF_ARM_HISI_PCIE_PMU_ONLINE);
 943 }
 944 module_exit(hisi_pcie_module_exit);
 945
 946 MODULE_DESCRIPTION("HiSilicon PCIe PMU driver");
 947 MODULE_LICENSE("GPL v2");
 948 MODULE_AUTHOR("Qi Liu <liuqi115@huawei.com>");