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