ptt/hisi_ptt.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for HiSilicon PCIe tune and trace device
   4  *
   5  * Copyright (c) 2022 HiSilicon Technologies Co., Ltd.
   6  * Author: Yicong Yang <yangyicong@hisilicon.com>
   7  */
   8
   9 #include <linux/bitfield.h>
  10 #include <linux/bitops.h>
  11 #include <linux/cpuhotplug.h>
  12 #include <linux/delay.h>
  13 #include <linux/dma-mapping.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/io.h>
  16 #include <linux/iommu.h>
  17 #include <linux/iopoll.h>
  18 #include <linux/module.h>
  19 #include <linux/sysfs.h>
  20 #include <linux/vmalloc.h>
  21
  22 #include "hisi_ptt.h"
  23
  24 /* Dynamic CPU hotplug state used by PTT */
  25 static enum cpuhp_state hisi_ptt_pmu_online;
  26
  27 static bool hisi_ptt_wait_tuning_finish(struct hisi_ptt *hisi_ptt)
  28 {
  29         u32 val;
  30
  31         return !readl_poll_timeout(hisi_ptt->iobase + HISI_PTT_TUNING_INT_STAT,
  32                                    val, !(val & HISI_PTT_TUNING_INT_STAT_MASK),
  33                                    HISI_PTT_WAIT_POLL_INTERVAL_US,
  34                                    HISI_PTT_WAIT_TUNE_TIMEOUT_US);
  35 }
  36
  37 static ssize_t hisi_ptt_tune_attr_show(struct device *dev,
  38                                        struct device_attribute *attr,
  39                                        char *buf)
  40 {
  41         struct hisi_ptt *hisi_ptt = to_hisi_ptt(dev_get_drvdata(dev));
  42         struct dev_ext_attribute *ext_attr;
  43         struct hisi_ptt_tune_desc *desc;
  44         u32 reg;
  45         u16 val;
  46
  47         ext_attr = container_of(attr, struct dev_ext_attribute, attr);
  48         desc = ext_attr->var;
  49
  50         mutex_lock(&hisi_ptt->tune_lock);
  51
  52         reg = readl(hisi_ptt->iobase + HISI_PTT_TUNING_CTRL);
  53         reg &= ~(HISI_PTT_TUNING_CTRL_CODE | HISI_PTT_TUNING_CTRL_SUB);
  54         reg |= FIELD_PREP(HISI_PTT_TUNING_CTRL_CODE | HISI_PTT_TUNING_CTRL_SUB,
  55                           desc->event_code);
  56         writel(reg, hisi_ptt->iobase + HISI_PTT_TUNING_CTRL);
  57
  58         /* Write all 1 to indicates it's the read process */
  59         writel(~0U, hisi_ptt->iobase + HISI_PTT_TUNING_DATA);
  60
  61         if (!hisi_ptt_wait_tuning_finish(hisi_ptt)) {
  62                 mutex_unlock(&hisi_ptt->tune_lock);
  63                 return -ETIMEDOUT;
  64         }
  65
  66         reg = readl(hisi_ptt->iobase + HISI_PTT_TUNING_DATA);
  67         reg &= HISI_PTT_TUNING_DATA_VAL_MASK;
  68         val = FIELD_GET(HISI_PTT_TUNING_DATA_VAL_MASK, reg);
  69
  70         mutex_unlock(&hisi_ptt->tune_lock);
  71         return sysfs_emit(buf, "%u\n", val);
  72 }
  73
  74 static ssize_t hisi_ptt_tune_attr_store(struct device *dev,
  75                                         struct device_attribute *attr,
  76                                         const char *buf, size_t count)
  77 {
  78         struct hisi_ptt *hisi_ptt = to_hisi_ptt(dev_get_drvdata(dev));
  79         struct dev_ext_attribute *ext_attr;
  80         struct hisi_ptt_tune_desc *desc;
  81         u32 reg;
  82         u16 val;
  83
  84         ext_attr = container_of(attr, struct dev_ext_attribute, attr);
  85         desc = ext_attr->var;
  86
  87         if (kstrtou16(buf, 10, &val))
  88                 return -EINVAL;
  89
  90         mutex_lock(&hisi_ptt->tune_lock);
  91
  92         reg = readl(hisi_ptt->iobase + HISI_PTT_TUNING_CTRL);
  93         reg &= ~(HISI_PTT_TUNING_CTRL_CODE | HISI_PTT_TUNING_CTRL_SUB);
  94         reg |= FIELD_PREP(HISI_PTT_TUNING_CTRL_CODE | HISI_PTT_TUNING_CTRL_SUB,
  95                           desc->event_code);
  96         writel(reg, hisi_ptt->iobase + HISI_PTT_TUNING_CTRL);
  97         writel(FIELD_PREP(HISI_PTT_TUNING_DATA_VAL_MASK, val),
  98                hisi_ptt->iobase + HISI_PTT_TUNING_DATA);
  99
 100         if (!hisi_ptt_wait_tuning_finish(hisi_ptt)) {
 101                 mutex_unlock(&hisi_ptt->tune_lock);
 102                 return -ETIMEDOUT;
 103         }
 104
 105         mutex_unlock(&hisi_ptt->tune_lock);
 106         return count;
 107 }
 108
 109 #define HISI_PTT_TUNE_ATTR(_name, _val, _show, _store)                  \
 110         static struct hisi_ptt_tune_desc _name##_desc = {               \
 111                 .name = #_name,                                         \
 112                 .event_code = (_val),                                   \
 113         };                                                              \
 114         static struct dev_ext_attribute hisi_ptt_##_name##_attr = {     \
 115                 .attr   = __ATTR(_name, 0600, _show, _store),           \
 116                 .var    = &_name##_desc,                                \
 117         }
 118
 119 #define HISI_PTT_TUNE_ATTR_COMMON(_name, _val)          \
 120         HISI_PTT_TUNE_ATTR(_name, _val,                 \
 121                            hisi_ptt_tune_attr_show,     \
 122                            hisi_ptt_tune_attr_store)
 123
 124 /*
 125  * The value of the tuning event are composed of two parts: main event code
 126  * in BIT[0,15] and subevent code in BIT[16,23]. For example, qox_tx_cpl is
 127  * a subevent of 'Tx path QoS control' which for tuning the weight of Tx
 128  * completion TLPs. See hisi_ptt.rst documentation for more information.
 129  */
 130 #define HISI_PTT_TUNE_QOS_TX_CPL                (0x4 | (3 << 16))
 131 #define HISI_PTT_TUNE_QOS_TX_NP                 (0x4 | (4 << 16))
 132 #define HISI_PTT_TUNE_QOS_TX_P                  (0x4 | (5 << 16))
 133 #define HISI_PTT_TUNE_RX_ALLOC_BUF_LEVEL        (0x5 | (6 << 16))
 134 #define HISI_PTT_TUNE_TX_ALLOC_BUF_LEVEL        (0x5 | (7 << 16))
 135
 136 HISI_PTT_TUNE_ATTR_COMMON(qos_tx_cpl, HISI_PTT_TUNE_QOS_TX_CPL);
 137 HISI_PTT_TUNE_ATTR_COMMON(qos_tx_np, HISI_PTT_TUNE_QOS_TX_NP);
 138 HISI_PTT_TUNE_ATTR_COMMON(qos_tx_p, HISI_PTT_TUNE_QOS_TX_P);
 139 HISI_PTT_TUNE_ATTR_COMMON(rx_alloc_buf_level, HISI_PTT_TUNE_RX_ALLOC_BUF_LEVEL);
 140 HISI_PTT_TUNE_ATTR_COMMON(tx_alloc_buf_level, HISI_PTT_TUNE_TX_ALLOC_BUF_LEVEL);
 141
 142 static struct attribute *hisi_ptt_tune_attrs[] = {
 143         &hisi_ptt_qos_tx_cpl_attr.attr.attr,
 144         &hisi_ptt_qos_tx_np_attr.attr.attr,
 145         &hisi_ptt_qos_tx_p_attr.attr.attr,
 146         &hisi_ptt_rx_alloc_buf_level_attr.attr.attr,
 147         &hisi_ptt_tx_alloc_buf_level_attr.attr.attr,
 148         NULL,
 149 };
 150
 151 static struct attribute_group hisi_ptt_tune_group = {
 152         .name   = "tune",
 153         .attrs  = hisi_ptt_tune_attrs,
 154 };
 155
 156 static u16 hisi_ptt_get_filter_val(u16 devid, bool is_port)
 157 {
 158         if (is_port)
 159                 return BIT(HISI_PCIE_CORE_PORT_ID(devid & 0xff));
 160
 161         return devid;
 162 }
 163
 164 static bool hisi_ptt_wait_trace_hw_idle(struct hisi_ptt *hisi_ptt)
 165 {
 166         u32 val;
 167
 168         return !readl_poll_timeout_atomic(hisi_ptt->iobase + HISI_PTT_TRACE_STS,
 169                                           val, val & HISI_PTT_TRACE_IDLE,
 170                                           HISI_PTT_WAIT_POLL_INTERVAL_US,
 171                                           HISI_PTT_WAIT_TRACE_TIMEOUT_US);
 172 }
 173
 174 static void hisi_ptt_wait_dma_reset_done(struct hisi_ptt *hisi_ptt)
 175 {
 176         u32 val;
 177
 178         readl_poll_timeout_atomic(hisi_ptt->iobase + HISI_PTT_TRACE_WR_STS,
 179                                   val, !val, HISI_PTT_RESET_POLL_INTERVAL_US,
 180                                   HISI_PTT_RESET_TIMEOUT_US);
 181 }
 182
 183 static void hisi_ptt_trace_end(struct hisi_ptt *hisi_ptt)
 184 {
 185         writel(0, hisi_ptt->iobase + HISI_PTT_TRACE_CTRL);
 186         hisi_ptt->trace_ctrl.started = false;
 187 }
 188
 189 static int hisi_ptt_trace_start(struct hisi_ptt *hisi_ptt)
 190 {
 191         struct hisi_ptt_trace_ctrl *ctrl = &hisi_ptt->trace_ctrl;
 192         u32 val;
 193         int i;
 194
 195         /* Check device idle before start trace */
 196         if (!hisi_ptt_wait_trace_hw_idle(hisi_ptt)) {
 197                 pci_err(hisi_ptt->pdev, "Failed to start trace, the device is still busy\n");
 198                 return -EBUSY;
 199         }
 200
 201         ctrl->started = true;
 202
 203         /* Reset the DMA before start tracing */
 204         val = readl(hisi_ptt->iobase + HISI_PTT_TRACE_CTRL);
 205         val |= HISI_PTT_TRACE_CTRL_RST;
 206         writel(val, hisi_ptt->iobase + HISI_PTT_TRACE_CTRL);
 207
 208         hisi_ptt_wait_dma_reset_done(hisi_ptt);
 209
 210         val = readl(hisi_ptt->iobase + HISI_PTT_TRACE_CTRL);
 211         val &= ~HISI_PTT_TRACE_CTRL_RST;
 212         writel(val, hisi_ptt->iobase + HISI_PTT_TRACE_CTRL);
 213
 214         /* Reset the index of current buffer */
 215         hisi_ptt->trace_ctrl.buf_index = 0;
 216
 217         /* Zero the trace buffers */
 218         for (i = 0; i < HISI_PTT_TRACE_BUF_CNT; i++)
 219                 memset(ctrl->trace_buf[i].addr, 0, HISI_PTT_TRACE_BUF_SIZE);
 220
 221         /* Clear the interrupt status */
 222         writel(HISI_PTT_TRACE_INT_STAT_MASK, hisi_ptt->iobase + HISI_PTT_TRACE_INT_STAT);
 223         writel(0, hisi_ptt->iobase + HISI_PTT_TRACE_INT_MASK);
 224
 225         /* Set the trace control register */
 226         val = FIELD_PREP(HISI_PTT_TRACE_CTRL_TYPE_SEL, ctrl->type);
 227         val |= FIELD_PREP(HISI_PTT_TRACE_CTRL_RXTX_SEL, ctrl->direction);
 228         val |= FIELD_PREP(HISI_PTT_TRACE_CTRL_DATA_FORMAT, ctrl->format);
 229         val |= FIELD_PREP(HISI_PTT_TRACE_CTRL_TARGET_SEL, hisi_ptt->trace_ctrl.filter);
 230         if (!hisi_ptt->trace_ctrl.is_port)
 231                 val |= HISI_PTT_TRACE_CTRL_FILTER_MODE;
 232
 233         /* Start the Trace */
 234         val |= HISI_PTT_TRACE_CTRL_EN;
 235         writel(val, hisi_ptt->iobase + HISI_PTT_TRACE_CTRL);
 236
 237         return 0;
 238 }
 239
 240 static int hisi_ptt_update_aux(struct hisi_ptt *hisi_ptt, int index, bool stop)
 241 {
 242         struct hisi_ptt_trace_ctrl *ctrl = &hisi_ptt->trace_ctrl;
 243         struct perf_output_handle *handle = &ctrl->handle;
 244         struct perf_event *event = handle->event;
 245         struct hisi_ptt_pmu_buf *buf;
 246         size_t size;
 247         void *addr;
 248
 249         buf = perf_get_aux(handle);
 250         if (!buf || !handle->size)
 251                 return -EINVAL;
 252
 253         addr = ctrl->trace_buf[ctrl->buf_index].addr;
 254
 255         /*
 256          * If we're going to stop, read the size of already traced data from
 257          * HISI_PTT_TRACE_WR_STS. Otherwise we're coming from the interrupt,
 258          * the data size is always HISI_PTT_TRACE_BUF_SIZE.
 259          */
 260         if (stop) {
 261                 u32 reg;
 262
 263                 reg = readl(hisi_ptt->iobase + HISI_PTT_TRACE_WR_STS);
 264                 size = FIELD_GET(HISI_PTT_TRACE_WR_STS_WRITE, reg);
 265         } else {
 266                 size = HISI_PTT_TRACE_BUF_SIZE;
 267         }
 268
 269         memcpy(buf->base + buf->pos, addr, size);
 270         buf->pos += size;
 271
 272         /*
 273          * Just commit the traced data if we're going to stop. Otherwise if the
 274          * resident AUX buffer cannot contain the data of next trace buffer,
 275          * apply a new one.
 276          */
 277         if (stop) {
 278                 perf_aux_output_end(handle, buf->pos);
 279         } else if (buf->length - buf->pos < HISI_PTT_TRACE_BUF_SIZE) {
 280                 perf_aux_output_end(handle, buf->pos);
 281
 282                 buf = perf_aux_output_begin(handle, event);
 283                 if (!buf)
 284                         return -EINVAL;
 285
 286                 buf->pos = handle->head % buf->length;
 287                 if (buf->length - buf->pos < HISI_PTT_TRACE_BUF_SIZE) {
 288                         perf_aux_output_end(handle, 0);
 289                         return -EINVAL;
 290                 }
 291         }
 292
 293         return 0;
 294 }
 295
 296 static irqreturn_t hisi_ptt_isr(int irq, void *context)
 297 {
 298         struct hisi_ptt *hisi_ptt = context;
 299         u32 status, buf_idx;
 300
 301         status = readl(hisi_ptt->iobase + HISI_PTT_TRACE_INT_STAT);
 302         if (!(status & HISI_PTT_TRACE_INT_STAT_MASK))
 303                 return IRQ_NONE;
 304
 305         buf_idx = ffs(status) - 1;
 306
 307         /* Clear the interrupt status of buffer @buf_idx */
 308         writel(status, hisi_ptt->iobase + HISI_PTT_TRACE_INT_STAT);
 309
 310         /*
 311          * Update the AUX buffer and cache the current buffer index,
 312          * as we need to know this and save the data when the trace
 313          * is ended out of the interrupt handler. End the trace
 314          * if the updating fails.
 315          */
 316         if (hisi_ptt_update_aux(hisi_ptt, buf_idx, false))
 317                 hisi_ptt_trace_end(hisi_ptt);
 318         else
 319                 hisi_ptt->trace_ctrl.buf_index = (buf_idx + 1) % HISI_PTT_TRACE_BUF_CNT;
 320
 321         return IRQ_HANDLED;
 322 }
 323
 324 static void hisi_ptt_irq_free_vectors(void *pdev)
 325 {
 326         pci_free_irq_vectors(pdev);
 327 }
 328
 329 static int hisi_ptt_register_irq(struct hisi_ptt *hisi_ptt)
 330 {
 331         struct pci_dev *pdev = hisi_ptt->pdev;
 332         int ret;
 333
 334         ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
 335         if (ret < 0) {
 336                 pci_err(pdev, "failed to allocate irq vector, ret = %d\n", ret);
 337                 return ret;
 338         }
 339
 340         ret = devm_add_action_or_reset(&pdev->dev, hisi_ptt_irq_free_vectors, pdev);
 341         if (ret < 0)
 342                 return ret;
 343
 344         hisi_ptt->trace_irq = pci_irq_vector(pdev, HISI_PTT_TRACE_DMA_IRQ);
 345         ret = devm_request_irq(&pdev->dev, hisi_ptt->trace_irq, hisi_ptt_isr,
 346                                 IRQF_NOBALANCING | IRQF_NO_THREAD, DRV_NAME,
 347                                 hisi_ptt);
 348         if (ret) {
 349                 pci_err(pdev, "failed to request irq %d, ret = %d\n",
 350                         hisi_ptt->trace_irq, ret);
 351                 return ret;
 352         }
 353
 354         return 0;
 355 }
 356
 357 static void hisi_ptt_del_free_filter(struct hisi_ptt *hisi_ptt,
 358                                       struct hisi_ptt_filter_desc *filter)
 359 {
 360         if (filter->is_port)
 361                 hisi_ptt->port_mask &= ~hisi_ptt_get_filter_val(filter->devid, true);
 362
 363         list_del(&filter->list);
 364         kfree(filter->name);
 365         kfree(filter);
 366 }
 367
 368 static struct hisi_ptt_filter_desc *
 369 hisi_ptt_alloc_add_filter(struct hisi_ptt *hisi_ptt, u16 devid, bool is_port)
 370 {
 371         struct hisi_ptt_filter_desc *filter;
 372         u8 devfn = devid & 0xff;
 373         char *filter_name;
 374
 375         filter_name = kasprintf(GFP_KERNEL, "%04x:%02x:%02x.%d", pci_domain_nr(hisi_ptt->pdev->bus),
 376                                  PCI_BUS_NUM(devid), PCI_SLOT(devfn), PCI_FUNC(devfn));
 377         if (!filter_name) {
 378                 pci_err(hisi_ptt->pdev, "failed to allocate name for filter %04x:%02x:%02x.%d\n",
 379                         pci_domain_nr(hisi_ptt->pdev->bus), PCI_BUS_NUM(devid),
 380                         PCI_SLOT(devfn), PCI_FUNC(devfn));
 381                 return NULL;
 382         }
 383
 384         filter = kzalloc(sizeof(*filter), GFP_KERNEL);
 385         if (!filter) {
 386                 pci_err(hisi_ptt->pdev, "failed to add filter for %s\n",
 387                         filter_name);
 388                 kfree(filter_name);
 389                 return NULL;
 390         }
 391
 392         filter->name = filter_name;
 393         filter->is_port = is_port;
 394         filter->devid = devid;
 395
 396         if (filter->is_port) {
 397                 list_add_tail(&filter->list, &hisi_ptt->port_filters);
 398
 399                 /* Update the available port mask */
 400                 hisi_ptt->port_mask |= hisi_ptt_get_filter_val(filter->devid, true);
 401         } else {
 402                 list_add_tail(&filter->list, &hisi_ptt->req_filters);
 403         }
 404
 405         return filter;
 406 }
 407
 408 static ssize_t hisi_ptt_filter_show(struct device *dev, struct device_attribute *attr,
 409                                     char *buf)
 410 {
 411         struct hisi_ptt_filter_desc *filter;
 412         unsigned long filter_val;
 413
 414         filter = container_of(attr, struct hisi_ptt_filter_desc, attr);
 415         filter_val = hisi_ptt_get_filter_val(filter->devid, filter->is_port) |
 416                      (filter->is_port ? HISI_PTT_PMU_FILTER_IS_PORT : 0);
 417
 418         return sysfs_emit(buf, "0x%05lx\n", filter_val);
 419 }
 420
 421 static int hisi_ptt_create_rp_filter_attr(struct hisi_ptt *hisi_ptt,
 422                                           struct hisi_ptt_filter_desc *filter)
 423 {
 424         struct kobject *kobj = &hisi_ptt->hisi_ptt_pmu.dev->kobj;
 425
 426         sysfs_attr_init(&filter->attr.attr);
 427         filter->attr.attr.name = filter->name;
 428         filter->attr.attr.mode = 0400; /* DEVICE_ATTR_ADMIN_RO */
 429         filter->attr.show = hisi_ptt_filter_show;
 430
 431         return sysfs_add_file_to_group(kobj, &filter->attr.attr,
 432                                        HISI_PTT_RP_FILTERS_GRP_NAME);
 433 }
 434
 435 static void hisi_ptt_remove_rp_filter_attr(struct hisi_ptt *hisi_ptt,
 436                                           struct hisi_ptt_filter_desc *filter)
 437 {
 438         struct kobject *kobj = &hisi_ptt->hisi_ptt_pmu.dev->kobj;
 439
 440         sysfs_remove_file_from_group(kobj, &filter->attr.attr,
 441                                      HISI_PTT_RP_FILTERS_GRP_NAME);
 442 }
 443
 444 static int hisi_ptt_create_req_filter_attr(struct hisi_ptt *hisi_ptt,
 445                                            struct hisi_ptt_filter_desc *filter)
 446 {
 447         struct kobject *kobj = &hisi_ptt->hisi_ptt_pmu.dev->kobj;
 448
 449         sysfs_attr_init(&filter->attr.attr);
 450         filter->attr.attr.name = filter->name;
 451         filter->attr.attr.mode = 0400; /* DEVICE_ATTR_ADMIN_RO */
 452         filter->attr.show = hisi_ptt_filter_show;
 453
 454         return sysfs_add_file_to_group(kobj, &filter->attr.attr,
 455                                        HISI_PTT_REQ_FILTERS_GRP_NAME);
 456 }
 457
 458 static void hisi_ptt_remove_req_filter_attr(struct hisi_ptt *hisi_ptt,
 459                                            struct hisi_ptt_filter_desc *filter)
 460 {
 461         struct kobject *kobj = &hisi_ptt->hisi_ptt_pmu.dev->kobj;
 462
 463         sysfs_remove_file_from_group(kobj, &filter->attr.attr,
 464                                      HISI_PTT_REQ_FILTERS_GRP_NAME);
 465 }
 466
 467 static int hisi_ptt_create_filter_attr(struct hisi_ptt *hisi_ptt,
 468                                        struct hisi_ptt_filter_desc *filter)
 469 {
 470         int ret;
 471
 472         if (filter->is_port)
 473                 ret = hisi_ptt_create_rp_filter_attr(hisi_ptt, filter);
 474         else
 475                 ret = hisi_ptt_create_req_filter_attr(hisi_ptt, filter);
 476
 477         if (ret)
 478                 pci_err(hisi_ptt->pdev, "failed to create sysfs attribute for filter %s\n",
 479                         filter->name);
 480
 481         return ret;
 482 }
 483
 484 static void hisi_ptt_remove_filter_attr(struct hisi_ptt *hisi_ptt,
 485                                         struct hisi_ptt_filter_desc *filter)
 486 {
 487         if (filter->is_port)
 488                 hisi_ptt_remove_rp_filter_attr(hisi_ptt, filter);
 489         else
 490                 hisi_ptt_remove_req_filter_attr(hisi_ptt, filter);
 491 }
 492
 493 static void hisi_ptt_remove_all_filter_attributes(void *data)
 494 {
 495         struct hisi_ptt_filter_desc *filter;
 496         struct hisi_ptt *hisi_ptt = data;
 497
 498         mutex_lock(&hisi_ptt->filter_lock);
 499
 500         list_for_each_entry(filter, &hisi_ptt->req_filters, list)
 501                 hisi_ptt_remove_filter_attr(hisi_ptt, filter);
 502
 503         list_for_each_entry(filter, &hisi_ptt->port_filters, list)
 504                 hisi_ptt_remove_filter_attr(hisi_ptt, filter);
 505
 506         hisi_ptt->sysfs_inited = false;
 507         mutex_unlock(&hisi_ptt->filter_lock);
 508 }
 509
 510 static int hisi_ptt_init_filter_attributes(struct hisi_ptt *hisi_ptt)
 511 {
 512         struct hisi_ptt_filter_desc *filter;
 513         int ret;
 514
 515         mutex_lock(&hisi_ptt->filter_lock);
 516
 517         /*
 518          * Register the reset callback in the first stage. In reset we traverse
 519          * the filters list to remove the sysfs attributes so the callback can
 520          * be called safely even without below filter attributes creation.
 521          */
 522         ret = devm_add_action(&hisi_ptt->pdev->dev,
 523                               hisi_ptt_remove_all_filter_attributes,
 524                               hisi_ptt);
 525         if (ret)
 526                 goto out;
 527
 528         list_for_each_entry(filter, &hisi_ptt->port_filters, list) {
 529                 ret = hisi_ptt_create_filter_attr(hisi_ptt, filter);
 530                 if (ret)
 531                         goto out;
 532         }
 533
 534         list_for_each_entry(filter, &hisi_ptt->req_filters, list) {
 535                 ret = hisi_ptt_create_filter_attr(hisi_ptt, filter);
 536                 if (ret)
 537                         goto out;
 538         }
 539
 540         hisi_ptt->sysfs_inited = true;
 541 out:
 542         mutex_unlock(&hisi_ptt->filter_lock);
 543         return ret;
 544 }
 545
 546 static void hisi_ptt_update_filters(struct work_struct *work)
 547 {
 548         struct delayed_work *delayed_work = to_delayed_work(work);
 549         struct hisi_ptt_filter_update_info info;
 550         struct hisi_ptt_filter_desc *filter;
 551         struct hisi_ptt *hisi_ptt;
 552
 553         hisi_ptt = container_of(delayed_work, struct hisi_ptt, work);
 554
 555         if (!mutex_trylock(&hisi_ptt->filter_lock)) {
 556                 schedule_delayed_work(&hisi_ptt->work, HISI_PTT_WORK_DELAY_MS);
 557                 return;
 558         }
 559
 560         while (kfifo_get(&hisi_ptt->filter_update_kfifo, &info)) {
 561                 if (info.is_add) {
 562                         /*
 563                          * Notify the users if failed to add this filter, others
 564                          * still work and available. See the comments in
 565                          * hisi_ptt_init_filters().
 566                          */
 567                         filter = hisi_ptt_alloc_add_filter(hisi_ptt, info.devid, info.is_port);
 568                         if (!filter)
 569                                 continue;
 570
 571                         /*
 572                          * If filters' sysfs entries hasn't been initialized,
 573                          * then we're still at probe stage. Add the filters to
 574                          * the list and later hisi_ptt_init_filter_attributes()
 575                          * will create sysfs attributes for all the filters.
 576                          */
 577                         if (hisi_ptt->sysfs_inited &&
 578                             hisi_ptt_create_filter_attr(hisi_ptt, filter)) {
 579                                 hisi_ptt_del_free_filter(hisi_ptt, filter);
 580                                 continue;
 581                         }
 582                 } else {
 583                         struct hisi_ptt_filter_desc *tmp;
 584                         struct list_head *target_list;
 585
 586                         target_list = info.is_port ? &hisi_ptt->port_filters :
 587                                       &hisi_ptt->req_filters;
 588
 589                         list_for_each_entry_safe(filter, tmp, target_list, list)
 590                                 if (filter->devid == info.devid) {
 591                                         if (hisi_ptt->sysfs_inited)
 592                                                 hisi_ptt_remove_filter_attr(hisi_ptt, filter);
 593
 594                                         hisi_ptt_del_free_filter(hisi_ptt, filter);
 595                                         break;
 596                                 }
 597                 }
 598         }
 599
 600         mutex_unlock(&hisi_ptt->filter_lock);
 601 }
 602
 603 /*
 604  * A PCI bus notifier is used here for dynamically updating the filter
 605  * list.
 606  */
 607 static int hisi_ptt_notifier_call(struct notifier_block *nb, unsigned long action,
 608                                   void *data)
 609 {
 610         struct hisi_ptt *hisi_ptt = container_of(nb, struct hisi_ptt, hisi_ptt_nb);
 611         struct hisi_ptt_filter_update_info info;
 612         struct pci_dev *pdev, *root_port;
 613         struct device *dev = data;
 614         u32 port_devid;
 615
 616         pdev = to_pci_dev(dev);
 617         root_port = pcie_find_root_port(pdev);
 618         if (!root_port)
 619                 return 0;
 620
 621         port_devid = pci_dev_id(root_port);
 622         if (port_devid < hisi_ptt->lower_bdf ||
 623             port_devid > hisi_ptt->upper_bdf)
 624                 return 0;
 625
 626         info.is_port = pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT;
 627         info.devid = pci_dev_id(pdev);
 628
 629         switch (action) {
 630         case BUS_NOTIFY_ADD_DEVICE:
 631                 info.is_add = true;
 632                 break;
 633         case BUS_NOTIFY_DEL_DEVICE:
 634                 info.is_add = false;
 635                 break;
 636         default:
 637                 return 0;
 638         }
 639
 640         /*
 641          * The FIFO size is 16 which is sufficient for almost all the cases,
 642          * since each PCIe core will have most 8 Root Ports (typically only
 643          * 1~4 Root Ports). On failure log the failed filter and let user
 644          * handle it.
 645          */
 646         if (kfifo_in_spinlocked(&hisi_ptt->filter_update_kfifo, &info, 1,
 647                                 &hisi_ptt->filter_update_lock))
 648                 schedule_delayed_work(&hisi_ptt->work, 0);
 649         else
 650                 pci_warn(hisi_ptt->pdev,
 651                          "filter update fifo overflow for target %s\n",
 652                          pci_name(pdev));
 653
 654         return 0;
 655 }
 656
 657 static int hisi_ptt_init_filters(struct pci_dev *pdev, void *data)
 658 {
 659         struct pci_dev *root_port = pcie_find_root_port(pdev);
 660         struct hisi_ptt_filter_desc *filter;
 661         struct hisi_ptt *hisi_ptt = data;
 662         u32 port_devid;
 663
 664         if (!root_port)
 665                 return 0;
 666
 667         port_devid = pci_dev_id(root_port);
 668         if (port_devid < hisi_ptt->lower_bdf ||
 669             port_devid > hisi_ptt->upper_bdf)
 670                 return 0;
 671
 672         /*
 673          * We won't fail the probe if filter allocation failed here. The filters
 674          * should be partial initialized and users would know which filter fails
 675          * through the log. Other functions of PTT device are still available.
 676          */
 677         filter = hisi_ptt_alloc_add_filter(hisi_ptt, pci_dev_id(pdev),
 678                                             pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT);
 679         if (!filter)
 680                 return -ENOMEM;
 681
 682         return 0;
 683 }
 684
 685 static void hisi_ptt_release_filters(void *data)
 686 {
 687         struct hisi_ptt_filter_desc *filter, *tmp;
 688         struct hisi_ptt *hisi_ptt = data;
 689
 690         list_for_each_entry_safe(filter, tmp, &hisi_ptt->req_filters, list)
 691                 hisi_ptt_del_free_filter(hisi_ptt, filter);
 692
 693         list_for_each_entry_safe(filter, tmp, &hisi_ptt->port_filters, list)
 694                 hisi_ptt_del_free_filter(hisi_ptt, filter);
 695 }
 696
 697 static int hisi_ptt_config_trace_buf(struct hisi_ptt *hisi_ptt)
 698 {
 699         struct hisi_ptt_trace_ctrl *ctrl = &hisi_ptt->trace_ctrl;
 700         struct device *dev = &hisi_ptt->pdev->dev;
 701         int i;
 702
 703         ctrl->trace_buf = devm_kcalloc(dev, HISI_PTT_TRACE_BUF_CNT,
 704                                        sizeof(*ctrl->trace_buf), GFP_KERNEL);
 705         if (!ctrl->trace_buf)
 706                 return -ENOMEM;
 707
 708         for (i = 0; i < HISI_PTT_TRACE_BUF_CNT; ++i) {
 709                 ctrl->trace_buf[i].addr = dmam_alloc_coherent(dev, HISI_PTT_TRACE_BUF_SIZE,
 710                                                              &ctrl->trace_buf[i].dma,
 711                                                              GFP_KERNEL);
 712                 if (!ctrl->trace_buf[i].addr)
 713                         return -ENOMEM;
 714         }
 715
 716         /* Configure the trace DMA buffer */
 717         for (i = 0; i < HISI_PTT_TRACE_BUF_CNT; i++) {
 718                 writel(lower_32_bits(ctrl->trace_buf[i].dma),
 719                        hisi_ptt->iobase + HISI_PTT_TRACE_ADDR_BASE_LO_0 +
 720                        i * HISI_PTT_TRACE_ADDR_STRIDE);
 721                 writel(upper_32_bits(ctrl->trace_buf[i].dma),
 722                        hisi_ptt->iobase + HISI_PTT_TRACE_ADDR_BASE_HI_0 +
 723                        i * HISI_PTT_TRACE_ADDR_STRIDE);
 724         }
 725         writel(HISI_PTT_TRACE_BUF_SIZE, hisi_ptt->iobase + HISI_PTT_TRACE_ADDR_SIZE);
 726
 727         return 0;
 728 }
 729
 730 static int hisi_ptt_init_ctrls(struct hisi_ptt *hisi_ptt)
 731 {
 732         struct pci_dev *pdev = hisi_ptt->pdev;
 733         struct pci_bus *bus;
 734         int ret;
 735         u32 reg;
 736
 737         INIT_DELAYED_WORK(&hisi_ptt->work, hisi_ptt_update_filters);
 738         INIT_KFIFO(hisi_ptt->filter_update_kfifo);
 739         spin_lock_init(&hisi_ptt->filter_update_lock);
 740
 741         INIT_LIST_HEAD(&hisi_ptt->port_filters);
 742         INIT_LIST_HEAD(&hisi_ptt->req_filters);
 743         mutex_init(&hisi_ptt->filter_lock);
 744
 745         ret = hisi_ptt_config_trace_buf(hisi_ptt);
 746         if (ret)
 747                 return ret;
 748
 749         /*
 750          * The device range register provides the information about the root
 751          * ports which the RCiEP can control and trace. The RCiEP and the root
 752          * ports which it supports are on the same PCIe core, with same domain
 753          * number but maybe different bus number. The device range register
 754          * will tell us which root ports we can support, Bit[31:16] indicates
 755          * the upper BDF numbers of the root port, while Bit[15:0] indicates
 756          * the lower.
 757          */
 758         reg = readl(hisi_ptt->iobase + HISI_PTT_DEVICE_RANGE);
 759         hisi_ptt->upper_bdf = FIELD_GET(HISI_PTT_DEVICE_RANGE_UPPER, reg);
 760         hisi_ptt->lower_bdf = FIELD_GET(HISI_PTT_DEVICE_RANGE_LOWER, reg);
 761
 762         bus = pci_find_bus(pci_domain_nr(pdev->bus), PCI_BUS_NUM(hisi_ptt->upper_bdf));
 763         if (bus)
 764                 pci_walk_bus(bus, hisi_ptt_init_filters, hisi_ptt);
 765
 766         ret = devm_add_action_or_reset(&pdev->dev, hisi_ptt_release_filters, hisi_ptt);
 767         if (ret)
 768                 return ret;
 769
 770         hisi_ptt->trace_ctrl.on_cpu = -1;
 771         return 0;
 772 }
 773
 774 static ssize_t cpumask_show(struct device *dev, struct device_attribute *attr,
 775                             char *buf)
 776 {
 777         struct hisi_ptt *hisi_ptt = to_hisi_ptt(dev_get_drvdata(dev));
 778         const cpumask_t *cpumask = cpumask_of_node(dev_to_node(&hisi_ptt->pdev->dev));
 779
 780         return cpumap_print_to_pagebuf(true, buf, cpumask);
 781 }
 782 static DEVICE_ATTR_RO(cpumask);
 783
 784 static struct attribute *hisi_ptt_cpumask_attrs[] = {
 785         &dev_attr_cpumask.attr,
 786         NULL
 787 };
 788
 789 static const struct attribute_group hisi_ptt_cpumask_attr_group = {
 790         .attrs = hisi_ptt_cpumask_attrs,
 791 };
 792
 793 /*
 794  * Bit 19 indicates the filter type, 1 for Root Port filter and 0 for Requester
 795  * filter. Bit[15:0] indicates the filter value, for Root Port filter it's
 796  * a bit mask of desired ports and for Requester filter it's the Requester ID
 797  * of the desired PCIe function. Bit[18:16] is reserved for extension.
 798  *
 799  * See hisi_ptt.rst documentation for detailed information.
 800  */
 801 PMU_FORMAT_ATTR(filter,         "config:0-19");
 802 PMU_FORMAT_ATTR(direction,      "config:20-23");
 803 PMU_FORMAT_ATTR(type,           "config:24-31");
 804 PMU_FORMAT_ATTR(format,         "config:32-35");
 805
 806 static struct attribute *hisi_ptt_pmu_format_attrs[] = {
 807         &format_attr_filter.attr,
 808         &format_attr_direction.attr,
 809         &format_attr_type.attr,
 810         &format_attr_format.attr,
 811         NULL
 812 };
 813
 814 static struct attribute_group hisi_ptt_pmu_format_group = {
 815         .name = "format",
 816         .attrs = hisi_ptt_pmu_format_attrs,
 817 };
 818
 819 static ssize_t hisi_ptt_filter_multiselect_show(struct device *dev,
 820                                                 struct device_attribute *attr,
 821                                                 char *buf)
 822 {
 823         struct dev_ext_attribute *ext_attr;
 824
 825         ext_attr = container_of(attr, struct dev_ext_attribute, attr);
 826         return sysfs_emit(buf, "%s\n", (char *)ext_attr->var);
 827 }
 828
 829 static struct dev_ext_attribute root_port_filters_multiselect = {
 830         .attr = {
 831                 .attr = { .name = "multiselect", .mode = 0400 },
 832                 .show = hisi_ptt_filter_multiselect_show,
 833         },
 834         .var = "1",
 835 };
 836
 837 static struct attribute *hisi_ptt_pmu_root_ports_attrs[] = {
 838         &root_port_filters_multiselect.attr.attr,
 839         NULL
 840 };
 841
 842 static struct attribute_group hisi_ptt_pmu_root_ports_group = {
 843         .name = HISI_PTT_RP_FILTERS_GRP_NAME,
 844         .attrs = hisi_ptt_pmu_root_ports_attrs,
 845 };
 846
 847 static struct dev_ext_attribute requester_filters_multiselect = {
 848         .attr = {
 849                 .attr = { .name = "multiselect", .mode = 0400 },
 850                 .show = hisi_ptt_filter_multiselect_show,
 851         },
 852         .var = "0",
 853 };
 854
 855 static struct attribute *hisi_ptt_pmu_requesters_attrs[] = {
 856         &requester_filters_multiselect.attr.attr,
 857         NULL
 858 };
 859
 860 static struct attribute_group hisi_ptt_pmu_requesters_group = {
 861         .name = HISI_PTT_REQ_FILTERS_GRP_NAME,
 862         .attrs = hisi_ptt_pmu_requesters_attrs,
 863 };
 864
 865 static const struct attribute_group *hisi_ptt_pmu_groups[] = {
 866         &hisi_ptt_cpumask_attr_group,
 867         &hisi_ptt_pmu_format_group,
 868         &hisi_ptt_tune_group,
 869         &hisi_ptt_pmu_root_ports_group,
 870         &hisi_ptt_pmu_requesters_group,
 871         NULL
 872 };
 873
 874 static int hisi_ptt_trace_valid_direction(u32 val)
 875 {
 876         /*
 877          * The direction values have different effects according to the data
 878          * format (specified in the parentheses). TLP set A/B means different
 879          * set of TLP types. See hisi_ptt.rst documentation for more details.
 880          */
 881         static const u32 hisi_ptt_trace_available_direction[] = {
 882                 0,      /* inbound(4DW) or reserved(8DW) */
 883                 1,      /* outbound(4DW) */
 884                 2,      /* {in, out}bound(4DW) or inbound(8DW), TLP set A */
 885                 3,      /* {in, out}bound(4DW) or inbound(8DW), TLP set B */
 886         };
 887         int i;
 888
 889         for (i = 0; i < ARRAY_SIZE(hisi_ptt_trace_available_direction); i++) {
 890                 if (val == hisi_ptt_trace_available_direction[i])
 891                         return 0;
 892         }
 893
 894         return -EINVAL;
 895 }
 896
 897 static int hisi_ptt_trace_valid_type(u32 val)
 898 {
 899         /* Different types can be set simultaneously */
 900         static const u32 hisi_ptt_trace_available_type[] = {
 901                 1,      /* posted_request */
 902                 2,      /* non-posted_request */
 903                 4,      /* completion */
 904         };
 905         int i;
 906
 907         if (!val)
 908                 return -EINVAL;
 909
 910         /*
 911          * Walk the available list and clear the valid bits of
 912          * the config. If there is any resident bit after the
 913          * walk then the config is invalid.
 914          */
 915         for (i = 0; i < ARRAY_SIZE(hisi_ptt_trace_available_type); i++)
 916                 val &= ~hisi_ptt_trace_available_type[i];
 917
 918         if (val)
 919                 return -EINVAL;
 920
 921         return 0;
 922 }
 923
 924 static int hisi_ptt_trace_valid_format(u32 val)
 925 {
 926         static const u32 hisi_ptt_trace_availble_format[] = {
 927                 0,      /* 4DW */
 928                 1,      /* 8DW */
 929         };
 930         int i;
 931
 932         for (i = 0; i < ARRAY_SIZE(hisi_ptt_trace_availble_format); i++) {
 933                 if (val == hisi_ptt_trace_availble_format[i])
 934                         return 0;
 935         }
 936
 937         return -EINVAL;
 938 }
 939
 940 static int hisi_ptt_trace_valid_filter(struct hisi_ptt *hisi_ptt, u64 config)
 941 {
 942         unsigned long val, port_mask = hisi_ptt->port_mask;
 943         struct hisi_ptt_filter_desc *filter;
 944         int ret = 0;
 945
 946         hisi_ptt->trace_ctrl.is_port = FIELD_GET(HISI_PTT_PMU_FILTER_IS_PORT, config);
 947         val = FIELD_GET(HISI_PTT_PMU_FILTER_VAL_MASK, config);
 948
 949         /*
 950          * Port filters are defined as bit mask. For port filters, check
 951          * the bits in the @val are within the range of hisi_ptt->port_mask
 952          * and whether it's empty or not, otherwise user has specified
 953          * some unsupported root ports.
 954          *
 955          * For Requester ID filters, walk the available filter list to see
 956          * whether we have one matched.
 957          */
 958         mutex_lock(&hisi_ptt->filter_lock);
 959         if (!hisi_ptt->trace_ctrl.is_port) {
 960                 list_for_each_entry(filter, &hisi_ptt->req_filters, list) {
 961                         if (val == hisi_ptt_get_filter_val(filter->devid, filter->is_port))
 962                                 goto out;
 963                 }
 964         } else if (bitmap_subset(&val, &port_mask, BITS_PER_LONG)) {
 965                 goto out;
 966         }
 967
 968         ret = -EINVAL;
 969 out:
 970         mutex_unlock(&hisi_ptt->filter_lock);
 971         return ret;
 972 }
 973
 974 static void hisi_ptt_pmu_init_configs(struct hisi_ptt *hisi_ptt, struct perf_event *event)
 975 {
 976         struct hisi_ptt_trace_ctrl *ctrl = &hisi_ptt->trace_ctrl;
 977         u32 val;
 978
 979         val = FIELD_GET(HISI_PTT_PMU_FILTER_VAL_MASK, event->attr.config);
 980         hisi_ptt->trace_ctrl.filter = val;
 981
 982         val = FIELD_GET(HISI_PTT_PMU_DIRECTION_MASK, event->attr.config);
 983         ctrl->direction = val;
 984
 985         val = FIELD_GET(HISI_PTT_PMU_TYPE_MASK, event->attr.config);
 986         ctrl->type = val;
 987
 988         val = FIELD_GET(HISI_PTT_PMU_FORMAT_MASK, event->attr.config);
 989         ctrl->format = val;
 990 }
 991
 992 static int hisi_ptt_pmu_event_init(struct perf_event *event)
 993 {
 994         struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);
 995         int ret;
 996         u32 val;
 997
 998         if (event->cpu < 0) {
 999                 dev_dbg(event->pmu->dev, "Per-task mode not supported\n");
1000                 return -EOPNOTSUPP;
1001         }
1002
1003         if (event->attach_state & PERF_ATTACH_TASK)
1004                 return -EOPNOTSUPP;
1005
1006         if (event->attr.type != hisi_ptt->hisi_ptt_pmu.type)
1007                 return -ENOENT;
1008
1009         ret = hisi_ptt_trace_valid_filter(hisi_ptt, event->attr.config);
1010         if (ret < 0)
1011                 return ret;
1012
1013         val = FIELD_GET(HISI_PTT_PMU_DIRECTION_MASK, event->attr.config);
1014         ret = hisi_ptt_trace_valid_direction(val);
1015         if (ret < 0)
1016                 return ret;
1017
1018         val = FIELD_GET(HISI_PTT_PMU_TYPE_MASK, event->attr.config);
1019         ret = hisi_ptt_trace_valid_type(val);
1020         if (ret < 0)
1021                 return ret;
1022
1023         val = FIELD_GET(HISI_PTT_PMU_FORMAT_MASK, event->attr.config);
1024         return hisi_ptt_trace_valid_format(val);
1025 }
1026
1027 static void *hisi_ptt_pmu_setup_aux(struct perf_event *event, void **pages,
1028                                     int nr_pages, bool overwrite)
1029 {
1030         struct hisi_ptt_pmu_buf *buf;
1031         struct page **pagelist;
1032         int i;
1033
1034         if (overwrite) {
1035                 dev_warn(event->pmu->dev, "Overwrite mode is not supported\n");
1036                 return NULL;
1037         }
1038
1039         /* If the pages size less than buffers, we cannot start trace */
1040         if (nr_pages < HISI_PTT_TRACE_TOTAL_BUF_SIZE / PAGE_SIZE)
1041                 return NULL;
1042
1043         buf = kzalloc(sizeof(*buf), GFP_KERNEL);
1044         if (!buf)
1045                 return NULL;
1046
1047         pagelist = kcalloc(nr_pages, sizeof(*pagelist), GFP_KERNEL);
1048         if (!pagelist)
1049                 goto err;
1050
1051         for (i = 0; i < nr_pages; i++)
1052                 pagelist[i] = virt_to_page(pages[i]);
1053
1054         buf->base = vmap(pagelist, nr_pages, VM_MAP, PAGE_KERNEL);
1055         if (!buf->base) {
1056                 kfree(pagelist);
1057                 goto err;
1058         }
1059
1060         buf->nr_pages = nr_pages;
1061         buf->length = nr_pages * PAGE_SIZE;
1062         buf->pos = 0;
1063
1064         kfree(pagelist);
1065         return buf;
1066 err:
1067         kfree(buf);
1068         return NULL;
1069 }
1070
1071 static void hisi_ptt_pmu_free_aux(void *aux)
1072 {
1073         struct hisi_ptt_pmu_buf *buf = aux;
1074
1075         vunmap(buf->base);
1076         kfree(buf);
1077 }
1078
1079 static void hisi_ptt_pmu_start(struct perf_event *event, int flags)
1080 {
1081         struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);
1082         struct perf_output_handle *handle = &hisi_ptt->trace_ctrl.handle;
1083         struct hw_perf_event *hwc = &event->hw;
1084         struct device *dev = event->pmu->dev;
1085         struct hisi_ptt_pmu_buf *buf;
1086         int cpu = event->cpu;
1087         int ret;
1088
1089         hwc->state = 0;
1090
1091         /* Serialize the perf process if user specified several CPUs */
1092         spin_lock(&hisi_ptt->pmu_lock);
1093         if (hisi_ptt->trace_ctrl.started) {
1094                 dev_dbg(dev, "trace has already started\n");
1095                 goto stop;
1096         }
1097
1098         /*
1099          * Handle the interrupt on the same cpu which starts the trace to avoid
1100          * context mismatch. Otherwise we'll trigger the WARN from the perf
1101          * core in event_function_local(). If CPU passed is offline we'll fail
1102          * here, just log it since we can do nothing here.
1103          */
1104         ret = irq_set_affinity(hisi_ptt->trace_irq, cpumask_of(cpu));
1105         if (ret)
1106                 dev_warn(dev, "failed to set the affinity of trace interrupt\n");
1107
1108         hisi_ptt->trace_ctrl.on_cpu = cpu;
1109
1110         buf = perf_aux_output_begin(handle, event);
1111         if (!buf) {
1112                 dev_dbg(dev, "aux output begin failed\n");
1113                 goto stop;
1114         }
1115
1116         buf->pos = handle->head % buf->length;
1117
1118         hisi_ptt_pmu_init_configs(hisi_ptt, event);
1119
1120         ret = hisi_ptt_trace_start(hisi_ptt);
1121         if (ret) {
1122                 dev_dbg(dev, "trace start failed, ret = %d\n", ret);
1123                 perf_aux_output_end(handle, 0);
1124                 goto stop;
1125         }
1126
1127         spin_unlock(&hisi_ptt->pmu_lock);
1128         return;
1129 stop:
1130         event->hw.state |= PERF_HES_STOPPED;
1131         spin_unlock(&hisi_ptt->pmu_lock);
1132 }
1133
1134 static void hisi_ptt_pmu_stop(struct perf_event *event, int flags)
1135 {
1136         struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);
1137         struct hw_perf_event *hwc = &event->hw;
1138
1139         if (hwc->state & PERF_HES_STOPPED)
1140                 return;
1141
1142         spin_lock(&hisi_ptt->pmu_lock);
1143         if (hisi_ptt->trace_ctrl.started) {
1144                 hisi_ptt_trace_end(hisi_ptt);
1145
1146                 if (!hisi_ptt_wait_trace_hw_idle(hisi_ptt))
1147                         dev_warn(event->pmu->dev, "Device is still busy\n");
1148
1149                 hisi_ptt_update_aux(hisi_ptt, hisi_ptt->trace_ctrl.buf_index, true);
1150         }
1151         spin_unlock(&hisi_ptt->pmu_lock);
1152
1153         hwc->state |= PERF_HES_STOPPED;
1154         perf_event_update_userpage(event);
1155         hwc->state |= PERF_HES_UPTODATE;
1156 }
1157
1158 static int hisi_ptt_pmu_add(struct perf_event *event, int flags)
1159 {
1160         struct hisi_ptt *hisi_ptt = to_hisi_ptt(event->pmu);
1161         struct hw_perf_event *hwc = &event->hw;
1162         int cpu = event->cpu;
1163
1164         /* Only allow the cpus on the device's node to add the event */
1165         if (!cpumask_test_cpu(cpu, cpumask_of_node(dev_to_node(&hisi_ptt->pdev->dev))))
1166                 return 0;
1167
1168         hwc->state = PERF_HES_STOPPED | PERF_HES_UPTODATE;
1169
1170         if (flags & PERF_EF_START) {
1171                 hisi_ptt_pmu_start(event, PERF_EF_RELOAD);
1172                 if (hwc->state & PERF_HES_STOPPED)
1173                         return -EINVAL;
1174         }
1175
1176         return 0;
1177 }
1178
1179 static void hisi_ptt_pmu_del(struct perf_event *event, int flags)
1180 {
1181         hisi_ptt_pmu_stop(event, PERF_EF_UPDATE);
1182 }
1183
1184 static void hisi_ptt_pmu_read(struct perf_event *event)
1185 {
1186 }
1187
1188 static void hisi_ptt_remove_cpuhp_instance(void *hotplug_node)
1189 {
1190         cpuhp_state_remove_instance_nocalls(hisi_ptt_pmu_online, hotplug_node);
1191 }
1192
1193 static void hisi_ptt_unregister_pmu(void *pmu)
1194 {
1195         perf_pmu_unregister(pmu);
1196 }
1197
1198 static int hisi_ptt_register_pmu(struct hisi_ptt *hisi_ptt)
1199 {
1200         u16 core_id, sicl_id;
1201         char *pmu_name;
1202         u32 reg;
1203         int ret;
1204
1205         ret = cpuhp_state_add_instance_nocalls(hisi_ptt_pmu_online,
1206                                                &hisi_ptt->hotplug_node);
1207         if (ret)
1208                 return ret;
1209
1210         ret = devm_add_action_or_reset(&hisi_ptt->pdev->dev,
1211                                        hisi_ptt_remove_cpuhp_instance,
1212                                        &hisi_ptt->hotplug_node);
1213         if (ret)
1214                 return ret;
1215
1216         mutex_init(&hisi_ptt->tune_lock);
1217         spin_lock_init(&hisi_ptt->pmu_lock);
1218
1219         hisi_ptt->hisi_ptt_pmu = (struct pmu) {
1220                 .module         = THIS_MODULE,
1221                 .capabilities   = PERF_PMU_CAP_EXCLUSIVE | PERF_PMU_CAP_NO_EXCLUDE,
1222                 .task_ctx_nr    = perf_sw_context,
1223                 .attr_groups    = hisi_ptt_pmu_groups,
1224                 .event_init     = hisi_ptt_pmu_event_init,
1225                 .setup_aux      = hisi_ptt_pmu_setup_aux,
1226                 .free_aux       = hisi_ptt_pmu_free_aux,
1227                 .start          = hisi_ptt_pmu_start,
1228                 .stop           = hisi_ptt_pmu_stop,
1229                 .add            = hisi_ptt_pmu_add,
1230                 .del            = hisi_ptt_pmu_del,
1231                 .read           = hisi_ptt_pmu_read,
1232         };
1233
1234         reg = readl(hisi_ptt->iobase + HISI_PTT_LOCATION);
1235         core_id = FIELD_GET(HISI_PTT_CORE_ID, reg);
1236         sicl_id = FIELD_GET(HISI_PTT_SICL_ID, reg);
1237
1238         pmu_name = devm_kasprintf(&hisi_ptt->pdev->dev, GFP_KERNEL, "hisi_ptt%u_%u",
1239                                   sicl_id, core_id);
1240         if (!pmu_name)
1241                 return -ENOMEM;
1242
1243         ret = perf_pmu_register(&hisi_ptt->hisi_ptt_pmu, pmu_name, -1);
1244         if (ret)
1245                 return ret;
1246
1247         return devm_add_action_or_reset(&hisi_ptt->pdev->dev,
1248                                         hisi_ptt_unregister_pmu,
1249                                         &hisi_ptt->hisi_ptt_pmu);
1250 }
1251
1252 static void hisi_ptt_unregister_filter_update_notifier(void *data)
1253 {
1254         struct hisi_ptt *hisi_ptt = data;
1255
1256         bus_unregister_notifier(&pci_bus_type, &hisi_ptt->hisi_ptt_nb);
1257
1258         /* Cancel any work that has been queued */
1259         cancel_delayed_work_sync(&hisi_ptt->work);
1260 }
1261
1262 /* Register the bus notifier for dynamically updating the filter list */
1263 static int hisi_ptt_register_filter_update_notifier(struct hisi_ptt *hisi_ptt)
1264 {
1265         int ret;
1266
1267         hisi_ptt->hisi_ptt_nb.notifier_call = hisi_ptt_notifier_call;
1268         ret = bus_register_notifier(&pci_bus_type, &hisi_ptt->hisi_ptt_nb);
1269         if (ret)
1270                 return ret;
1271
1272         return devm_add_action_or_reset(&hisi_ptt->pdev->dev,
1273                                         hisi_ptt_unregister_filter_update_notifier,
1274                                         hisi_ptt);
1275 }
1276
1277 /*
1278  * The DMA of PTT trace can only use direct mappings due to some
1279  * hardware restriction. Check whether there is no IOMMU or the
1280  * policy of the IOMMU domain is passthrough, otherwise the trace
1281  * cannot work.
1282  *
1283  * The PTT device is supposed to behind an ARM SMMUv3, which
1284  * should have passthrough the device by a quirk.
1285  */
1286 static int hisi_ptt_check_iommu_mapping(struct pci_dev *pdev)
1287 {
1288         struct iommu_domain *iommu_domain;
1289
1290         iommu_domain = iommu_get_domain_for_dev(&pdev->dev);
1291         if (!iommu_domain || iommu_domain->type == IOMMU_DOMAIN_IDENTITY)
1292                 return 0;
1293
1294         return -EOPNOTSUPP;
1295 }
1296
1297 static int hisi_ptt_probe(struct pci_dev *pdev,
1298                           const struct pci_device_id *id)
1299 {
1300         struct hisi_ptt *hisi_ptt;
1301         int ret;
1302
1303         ret = hisi_ptt_check_iommu_mapping(pdev);
1304         if (ret) {
1305                 pci_err(pdev, "requires direct DMA mappings\n");
1306                 return ret;
1307         }
1308
1309         hisi_ptt = devm_kzalloc(&pdev->dev, sizeof(*hisi_ptt), GFP_KERNEL);
1310         if (!hisi_ptt)
1311                 return -ENOMEM;
1312
1313         hisi_ptt->pdev = pdev;
1314         pci_set_drvdata(pdev, hisi_ptt);
1315
1316         ret = pcim_enable_device(pdev);
1317         if (ret) {
1318                 pci_err(pdev, "failed to enable device, ret = %d\n", ret);
1319                 return ret;
1320         }
1321
1322         ret = pcim_iomap_regions(pdev, BIT(2), DRV_NAME);
1323         if (ret) {
1324                 pci_err(pdev, "failed to remap io memory, ret = %d\n", ret);
1325                 return ret;
1326         }
1327
1328         hisi_ptt->iobase = pcim_iomap_table(pdev)[2];
1329
1330         ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
1331         if (ret) {
1332                 pci_err(pdev, "failed to set 64 bit dma mask, ret = %d\n", ret);
1333                 return ret;
1334         }
1335
1336         pci_set_master(pdev);
1337
1338         ret = hisi_ptt_register_irq(hisi_ptt);
1339         if (ret)
1340                 return ret;
1341
1342         ret = hisi_ptt_init_ctrls(hisi_ptt);
1343         if (ret) {
1344                 pci_err(pdev, "failed to init controls, ret = %d\n", ret);
1345                 return ret;
1346         }
1347
1348         ret = hisi_ptt_register_filter_update_notifier(hisi_ptt);
1349         if (ret)
1350                 pci_warn(pdev, "failed to register filter update notifier, ret = %d", ret);
1351
1352         ret = hisi_ptt_register_pmu(hisi_ptt);
1353         if (ret) {
1354                 pci_err(pdev, "failed to register PMU device, ret = %d", ret);
1355                 return ret;
1356         }
1357
1358         ret = hisi_ptt_init_filter_attributes(hisi_ptt);
1359         if (ret) {
1360                 pci_err(pdev, "failed to init sysfs filter attributes, ret = %d", ret);
1361                 return ret;
1362         }
1363
1364         return 0;
1365 }
1366
1367 static const struct pci_device_id hisi_ptt_id_tbl[] = {
1368         { PCI_DEVICE(PCI_VENDOR_ID_HUAWEI, 0xa12e) },
1369         { }
1370 };
1371 MODULE_DEVICE_TABLE(pci, hisi_ptt_id_tbl);
1372
1373 static struct pci_driver hisi_ptt_driver = {
1374         .name = DRV_NAME,
1375         .id_table = hisi_ptt_id_tbl,
1376         .probe = hisi_ptt_probe,
1377 };
1378
1379 static int hisi_ptt_cpu_teardown(unsigned int cpu, struct hlist_node *node)
1380 {
1381         struct hisi_ptt *hisi_ptt;
1382         struct device *dev;
1383         int target, src;
1384
1385         hisi_ptt = hlist_entry_safe(node, struct hisi_ptt, hotplug_node);
1386         src = hisi_ptt->trace_ctrl.on_cpu;
1387         dev = hisi_ptt->hisi_ptt_pmu.dev;
1388
1389         if (!hisi_ptt->trace_ctrl.started || src != cpu)
1390                 return 0;
1391
1392         target = cpumask_any_but(cpumask_of_node(dev_to_node(&hisi_ptt->pdev->dev)), cpu);
1393         if (target >= nr_cpu_ids) {
1394                 dev_err(dev, "no available cpu for perf context migration\n");
1395                 return 0;
1396         }
1397
1398         perf_pmu_migrate_context(&hisi_ptt->hisi_ptt_pmu, src, target);
1399
1400         /*
1401          * Also make sure the interrupt bind to the migrated CPU as well. Warn
1402          * the user on failure here.
1403          */
1404         if (irq_set_affinity(hisi_ptt->trace_irq, cpumask_of(target)))
1405                 dev_warn(dev, "failed to set the affinity of trace interrupt\n");
1406
1407         hisi_ptt->trace_ctrl.on_cpu = target;
1408         return 0;
1409 }
1410
1411 static int __init hisi_ptt_init(void)
1412 {
1413         int ret;
1414
1415         ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, DRV_NAME, NULL,
1416                                       hisi_ptt_cpu_teardown);
1417         if (ret < 0)
1418                 return ret;
1419         hisi_ptt_pmu_online = ret;
1420
1421         ret = pci_register_driver(&hisi_ptt_driver);
1422         if (ret)
1423                 cpuhp_remove_multi_state(hisi_ptt_pmu_online);
1424
1425         return ret;
1426 }
1427 module_init(hisi_ptt_init);
1428
1429 static void __exit hisi_ptt_exit(void)
1430 {
1431         pci_unregister_driver(&hisi_ptt_driver);
1432         cpuhp_remove_multi_state(hisi_ptt_pmu_online);
1433 }
1434 module_exit(hisi_ptt_exit);
1435
1436 MODULE_LICENSE("GPL");
1437 MODULE_AUTHOR("Yicong Yang <yangyicong@hisilicon.com>");
1438 MODULE_DESCRIPTION("Driver for HiSilicon PCIe tune and trace device");