drivers/net/ethernet/mellanox/mlx5/core/eq.c

   1 /*
   2  * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/interrupt.h>
  34 #include <linux/notifier.h>
  35 #include <linux/module.h>
  36 #include <linux/mlx5/driver.h>
  37 #include <linux/mlx5/vport.h>
  38 #include <linux/mlx5/eq.h>
  39 #include <linux/mlx5/cmd.h>
  40 #ifdef CONFIG_RFS_ACCEL
  41 #include <linux/cpu_rmap.h>
  42 #endif
  43 #include "mlx5_core.h"
  44 #include "lib/eq.h"
  45 #include "fpga/core.h"
  46 #include "eswitch.h"
  47 #include "lib/clock.h"
  48 #include "diag/fw_tracer.h"
  49
  50 enum {
  51         MLX5_EQE_OWNER_INIT_VAL = 0x1,
  52 };
  53
  54 enum {
  55         MLX5_EQ_STATE_ARMED             = 0x9,
  56         MLX5_EQ_STATE_FIRED             = 0xa,
  57         MLX5_EQ_STATE_ALWAYS_ARMED      = 0xb,
  58 };
  59
  60 enum {
  61         MLX5_EQ_DOORBEL_OFFSET  = 0x40,
  62 };
  63
  64 struct mlx5_irq_info {
  65         cpumask_var_t mask;
  66         char name[MLX5_MAX_IRQ_NAME];
  67         void *context; /* dev_id provided to request_irq */
  68 };
  69
  70 struct mlx5_eq_table {
  71         struct list_head        comp_eqs_list;
  72         struct mlx5_eq          pages_eq;
  73         struct mlx5_eq          cmd_eq;
  74         struct mlx5_eq          async_eq;
  75
  76         struct atomic_notifier_head nh[MLX5_EVENT_TYPE_MAX];
  77
  78         /* Since CQ DB is stored in async_eq */
  79         struct mlx5_nb          cq_err_nb;
  80
  81         struct mutex            lock; /* sync async eqs creations */
  82         int                     num_comp_vectors;
  83         struct mlx5_irq_info    *irq_info;
  84 #ifdef CONFIG_RFS_ACCEL
  85         struct cpu_rmap         *rmap;
  86 #endif
  87 };
  88
  89 #define MLX5_ASYNC_EVENT_MASK ((1ull << MLX5_EVENT_TYPE_PATH_MIG)           | \
  90                                (1ull << MLX5_EVENT_TYPE_COMM_EST)           | \
  91                                (1ull << MLX5_EVENT_TYPE_SQ_DRAINED)         | \
  92                                (1ull << MLX5_EVENT_TYPE_CQ_ERROR)           | \
  93                                (1ull << MLX5_EVENT_TYPE_WQ_CATAS_ERROR)     | \
  94                                (1ull << MLX5_EVENT_TYPE_PATH_MIG_FAILED)    | \
  95                                (1ull << MLX5_EVENT_TYPE_WQ_INVAL_REQ_ERROR) | \
  96                                (1ull << MLX5_EVENT_TYPE_WQ_ACCESS_ERROR)    | \
  97                                (1ull << MLX5_EVENT_TYPE_PORT_CHANGE)        | \
  98                                (1ull << MLX5_EVENT_TYPE_SRQ_CATAS_ERROR)    | \
  99                                (1ull << MLX5_EVENT_TYPE_SRQ_LAST_WQE)       | \
 100                                (1ull << MLX5_EVENT_TYPE_SRQ_RQ_LIMIT))
 101
 102 static int mlx5_cmd_destroy_eq(struct mlx5_core_dev *dev, u8 eqn)
 103 {
 104         u32 out[MLX5_ST_SZ_DW(destroy_eq_out)] = {0};
 105         u32 in[MLX5_ST_SZ_DW(destroy_eq_in)]   = {0};
 106
 107         MLX5_SET(destroy_eq_in, in, opcode, MLX5_CMD_OP_DESTROY_EQ);
 108         MLX5_SET(destroy_eq_in, in, eq_number, eqn);
 109         return mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
 110 }
 111
 112 /* caller must eventually call mlx5_cq_put on the returned cq */
 113 static struct mlx5_core_cq *mlx5_eq_cq_get(struct mlx5_eq *eq, u32 cqn)
 114 {
 115         struct mlx5_cq_table *table = &eq->cq_table;
 116         struct mlx5_core_cq *cq = NULL;
 117
 118         rcu_read_lock();
 119         cq = radix_tree_lookup(&table->tree, cqn);
 120         if (likely(cq))
 121                 mlx5_cq_hold(cq);
 122         rcu_read_unlock();
 123
 124         return cq;
 125 }
 126
 127 static irqreturn_t mlx5_eq_comp_int(int irq, void *eq_ptr)
 128 {
 129         struct mlx5_eq_comp *eq_comp = eq_ptr;
 130         struct mlx5_eq *eq = eq_ptr;
 131         struct mlx5_eqe *eqe;
 132         int set_ci = 0;
 133         u32 cqn = -1;
 134
 135         while ((eqe = next_eqe_sw(eq))) {
 136                 struct mlx5_core_cq *cq;
 137                 /* Make sure we read EQ entry contents after we've
 138                  * checked the ownership bit.
 139                  */
 140                 dma_rmb();
 141                 /* Assume (eqe->type) is always MLX5_EVENT_TYPE_COMP */
 142                 cqn = be32_to_cpu(eqe->data.comp.cqn) & 0xffffff;
 143
 144                 cq = mlx5_eq_cq_get(eq, cqn);
 145                 if (likely(cq)) {
 146                         ++cq->arm_sn;
 147                         cq->comp(cq);
 148                         mlx5_cq_put(cq);
 149                 } else {
 150                         mlx5_core_warn(eq->dev, "Completion event for bogus CQ 0x%x\n", cqn);
 151                 }
 152
 153                 ++eq->cons_index;
 154                 ++set_ci;
 155
 156                 /* The HCA will think the queue has overflowed if we
 157                  * don't tell it we've been processing events.  We
 158                  * create our EQs with MLX5_NUM_SPARE_EQE extra
 159                  * entries, so we must update our consumer index at
 160                  * least that often.
 161                  */
 162                 if (unlikely(set_ci >= MLX5_NUM_SPARE_EQE)) {
 163                         eq_update_ci(eq, 0);
 164                         set_ci = 0;
 165                 }
 166         }
 167
 168         eq_update_ci(eq, 1);
 169
 170         if (cqn != -1)
 171                 tasklet_schedule(&eq_comp->tasklet_ctx.task);
 172
 173         return IRQ_HANDLED;
 174 }
 175
 176 /* Some architectures don't latch interrupts when they are disabled, so using
 177  * mlx5_eq_poll_irq_disabled could end up losing interrupts while trying to
 178  * avoid losing them.  It is not recommended to use it, unless this is the last
 179  * resort.
 180  */
 181 u32 mlx5_eq_poll_irq_disabled(struct mlx5_eq_comp *eq)
 182 {
 183         u32 count_eqe;
 184
 185         disable_irq(eq->core.irqn);
 186         count_eqe = eq->core.cons_index;
 187         mlx5_eq_comp_int(eq->core.irqn, eq);
 188         count_eqe = eq->core.cons_index - count_eqe;
 189         enable_irq(eq->core.irqn);
 190
 191         return count_eqe;
 192 }
 193
 194 static irqreturn_t mlx5_eq_async_int(int irq, void *eq_ptr)
 195 {
 196         struct mlx5_eq *eq = eq_ptr;
 197         struct mlx5_eq_table *eqt;
 198         struct mlx5_core_dev *dev;
 199         struct mlx5_eqe *eqe;
 200         int set_ci = 0;
 201
 202         dev = eq->dev;
 203         eqt = dev->priv.eq_table;
 204
 205         while ((eqe = next_eqe_sw(eq))) {
 206                 /*
 207                  * Make sure we read EQ entry contents after we've
 208                  * checked the ownership bit.
 209                  */
 210                 dma_rmb();
 211
 212                 if (likely(eqe->type < MLX5_EVENT_TYPE_MAX))
 213                         atomic_notifier_call_chain(&eqt->nh[eqe->type], eqe->type, eqe);
 214                 else
 215                         mlx5_core_warn_once(dev, "notifier_call_chain is not setup for eqe: %d\n", eqe->type);
 216
 217                 atomic_notifier_call_chain(&eqt->nh[MLX5_EVENT_TYPE_NOTIFY_ANY], eqe->type, eqe);
 218
 219                 ++eq->cons_index;
 220                 ++set_ci;
 221
 222                 /* The HCA will think the queue has overflowed if we
 223                  * don't tell it we've been processing events.  We
 224                  * create our EQs with MLX5_NUM_SPARE_EQE extra
 225                  * entries, so we must update our consumer index at
 226                  * least that often.
 227                  */
 228                 if (unlikely(set_ci >= MLX5_NUM_SPARE_EQE)) {
 229                         eq_update_ci(eq, 0);
 230                         set_ci = 0;
 231                 }
 232         }
 233
 234         eq_update_ci(eq, 1);
 235
 236         return IRQ_HANDLED;
 237 }
 238
 239 static void init_eq_buf(struct mlx5_eq *eq)
 240 {
 241         struct mlx5_eqe *eqe;
 242         int i;
 243
 244         for (i = 0; i < eq->nent; i++) {
 245                 eqe = get_eqe(eq, i);
 246                 eqe->owner = MLX5_EQE_OWNER_INIT_VAL;
 247         }
 248 }
 249
 250 static int
 251 create_map_eq(struct mlx5_core_dev *dev, struct mlx5_eq *eq, const char *name,
 252               struct mlx5_eq_param *param)
 253 {
 254         struct mlx5_eq_table *eq_table = dev->priv.eq_table;
 255         struct mlx5_cq_table *cq_table = &eq->cq_table;
 256         u32 out[MLX5_ST_SZ_DW(create_eq_out)] = {0};
 257         struct mlx5_priv *priv = &dev->priv;
 258         u8 vecidx = param->index;
 259         __be64 *pas;
 260         void *eqc;
 261         int inlen;
 262         u32 *in;
 263         int err;
 264
 265         if (eq_table->irq_info[vecidx].context)
 266                 return -EEXIST;
 267
 268         /* Init CQ table */
 269         memset(cq_table, 0, sizeof(*cq_table));
 270         spin_lock_init(&cq_table->lock);
 271         INIT_RADIX_TREE(&cq_table->tree, GFP_ATOMIC);
 272
 273         eq->nent = roundup_pow_of_two(param->nent + MLX5_NUM_SPARE_EQE);
 274         eq->cons_index = 0;
 275         err = mlx5_buf_alloc(dev, eq->nent * MLX5_EQE_SIZE, &eq->buf);
 276         if (err)
 277                 return err;
 278
 279         init_eq_buf(eq);
 280
 281         inlen = MLX5_ST_SZ_BYTES(create_eq_in) +
 282                 MLX5_FLD_SZ_BYTES(create_eq_in, pas[0]) * eq->buf.npages;
 283
 284         in = kvzalloc(inlen, GFP_KERNEL);
 285         if (!in) {
 286                 err = -ENOMEM;
 287                 goto err_buf;
 288         }
 289
 290         pas = (__be64 *)MLX5_ADDR_OF(create_eq_in, in, pas);
 291         mlx5_fill_page_array(&eq->buf, pas);
 292
 293         MLX5_SET(create_eq_in, in, opcode, MLX5_CMD_OP_CREATE_EQ);
 294         MLX5_SET64(create_eq_in, in, event_bitmask, param->mask);
 295
 296         eqc = MLX5_ADDR_OF(create_eq_in, in, eq_context_entry);
 297         MLX5_SET(eqc, eqc, log_eq_size, ilog2(eq->nent));
 298         MLX5_SET(eqc, eqc, uar_page, priv->uar->index);
 299         MLX5_SET(eqc, eqc, intr, vecidx);
 300         MLX5_SET(eqc, eqc, log_page_size,
 301                  eq->buf.page_shift - MLX5_ADAPTER_PAGE_SHIFT);
 302
 303         err = mlx5_cmd_exec(dev, in, inlen, out, sizeof(out));
 304         if (err)
 305                 goto err_in;
 306
 307         snprintf(eq_table->irq_info[vecidx].name, MLX5_MAX_IRQ_NAME, "%s@pci:%s",
 308                  name, pci_name(dev->pdev));
 309         eq_table->irq_info[vecidx].context = param->context;
 310
 311         eq->vecidx = vecidx;
 312         eq->eqn = MLX5_GET(create_eq_out, out, eq_number);
 313         eq->irqn = pci_irq_vector(dev->pdev, vecidx);
 314         eq->dev = dev;
 315         eq->doorbell = priv->uar->map + MLX5_EQ_DOORBEL_OFFSET;
 316         err = request_irq(eq->irqn, param->handler, 0,
 317                           eq_table->irq_info[vecidx].name, param->context);
 318         if (err)
 319                 goto err_eq;
 320
 321         err = mlx5_debug_eq_add(dev, eq);
 322         if (err)
 323                 goto err_irq;
 324
 325         /* EQs are created in ARMED state
 326          */
 327         eq_update_ci(eq, 1);
 328
 329         kvfree(in);
 330         return 0;
 331
 332 err_irq:
 333         free_irq(eq->irqn, eq);
 334
 335 err_eq:
 336         mlx5_cmd_destroy_eq(dev, eq->eqn);
 337
 338 err_in:
 339         kvfree(in);
 340
 341 err_buf:
 342         mlx5_buf_free(dev, &eq->buf);
 343         return err;
 344 }
 345
 346 static int destroy_unmap_eq(struct mlx5_core_dev *dev, struct mlx5_eq *eq)
 347 {
 348         struct mlx5_eq_table *eq_table = dev->priv.eq_table;
 349         struct mlx5_irq_info *irq_info;
 350         int err;
 351
 352         irq_info = &eq_table->irq_info[eq->vecidx];
 353
 354         mlx5_debug_eq_remove(dev, eq);
 355
 356         free_irq(eq->irqn, irq_info->context);
 357         irq_info->context = NULL;
 358
 359         err = mlx5_cmd_destroy_eq(dev, eq->eqn);
 360         if (err)
 361                 mlx5_core_warn(dev, "failed to destroy a previously created eq: eqn %d\n",
 362                                eq->eqn);
 363         synchronize_irq(eq->irqn);
 364
 365         mlx5_buf_free(dev, &eq->buf);
 366
 367         return err;
 368 }
 369
 370 int mlx5_eq_add_cq(struct mlx5_eq *eq, struct mlx5_core_cq *cq)
 371 {
 372         struct mlx5_cq_table *table = &eq->cq_table;
 373         int err;
 374
 375         spin_lock(&table->lock);
 376         err = radix_tree_insert(&table->tree, cq->cqn, cq);
 377         spin_unlock(&table->lock);
 378
 379         return err;
 380 }
 381
 382 int mlx5_eq_del_cq(struct mlx5_eq *eq, struct mlx5_core_cq *cq)
 383 {
 384         struct mlx5_cq_table *table = &eq->cq_table;
 385         struct mlx5_core_cq *tmp;
 386
 387         spin_lock(&table->lock);
 388         tmp = radix_tree_delete(&table->tree, cq->cqn);
 389         spin_unlock(&table->lock);
 390
 391         if (!tmp) {
 392                 mlx5_core_warn(eq->dev, "cq 0x%x not found in eq 0x%x tree\n", eq->eqn, cq->cqn);
 393                 return -ENOENT;
 394         }
 395
 396         if (tmp != cq) {
 397                 mlx5_core_warn(eq->dev, "corruption on cqn 0x%x in eq 0x%x\n", eq->eqn, cq->cqn);
 398                 return -EINVAL;
 399         }
 400
 401         return 0;
 402 }
 403
 404 int mlx5_eq_table_init(struct mlx5_core_dev *dev)
 405 {
 406         struct mlx5_eq_table *eq_table;
 407         int i, err;
 408
 409         eq_table = kvzalloc(sizeof(*eq_table), GFP_KERNEL);
 410         if (!eq_table)
 411                 return -ENOMEM;
 412
 413         dev->priv.eq_table = eq_table;
 414
 415         err = mlx5_eq_debugfs_init(dev);
 416         if (err)
 417                 goto kvfree_eq_table;
 418
 419         mutex_init(&eq_table->lock);
 420         for (i = 0; i < MLX5_EVENT_TYPE_MAX; i++)
 421                 ATOMIC_INIT_NOTIFIER_HEAD(&eq_table->nh[i]);
 422
 423         return 0;
 424
 425 kvfree_eq_table:
 426         kvfree(eq_table);
 427         dev->priv.eq_table = NULL;
 428         return err;
 429 }
 430
 431 void mlx5_eq_table_cleanup(struct mlx5_core_dev *dev)
 432 {
 433         mlx5_eq_debugfs_cleanup(dev);
 434         kvfree(dev->priv.eq_table);
 435 }
 436
 437 /* Async EQs */
 438
 439 static int create_async_eq(struct mlx5_core_dev *dev, const char *name,
 440                            struct mlx5_eq *eq, struct mlx5_eq_param *param)
 441 {
 442         struct mlx5_eq_table *eq_table = dev->priv.eq_table;
 443         int err;
 444
 445         mutex_lock(&eq_table->lock);
 446         if (param->index >= MLX5_EQ_MAX_ASYNC_EQS) {
 447                 err = -ENOSPC;
 448                 goto unlock;
 449         }
 450
 451         err = create_map_eq(dev, eq, name, param);
 452 unlock:
 453         mutex_unlock(&eq_table->lock);
 454         return err;
 455 }
 456
 457 static int destroy_async_eq(struct mlx5_core_dev *dev, struct mlx5_eq *eq)
 458 {
 459         struct mlx5_eq_table *eq_table = dev->priv.eq_table;
 460         int err;
 461
 462         mutex_lock(&eq_table->lock);
 463         err = destroy_unmap_eq(dev, eq);
 464         mutex_unlock(&eq_table->lock);
 465         return err;
 466 }
 467
 468 static int cq_err_event_notifier(struct notifier_block *nb,
 469                                  unsigned long type, void *data)
 470 {
 471         struct mlx5_eq_table *eqt;
 472         struct mlx5_core_cq *cq;
 473         struct mlx5_eqe *eqe;
 474         struct mlx5_eq *eq;
 475         u32 cqn;
 476
 477         /* type == MLX5_EVENT_TYPE_CQ_ERROR */
 478
 479         eqt = mlx5_nb_cof(nb, struct mlx5_eq_table, cq_err_nb);
 480         eq  = &eqt->async_eq;
 481         eqe = data;
 482
 483         cqn = be32_to_cpu(eqe->data.cq_err.cqn) & 0xffffff;
 484         mlx5_core_warn(eq->dev, "CQ error on CQN 0x%x, syndrome 0x%x\n",
 485                        cqn, eqe->data.cq_err.syndrome);
 486
 487         cq = mlx5_eq_cq_get(eq, cqn);
 488         if (unlikely(!cq)) {
 489                 mlx5_core_warn(eq->dev, "Async event for bogus CQ 0x%x\n", cqn);
 490                 return NOTIFY_OK;
 491         }
 492
 493         cq->event(cq, type);
 494
 495         mlx5_cq_put(cq);
 496
 497         return NOTIFY_OK;
 498 }
 499
 500 static u64 gather_async_events_mask(struct mlx5_core_dev *dev)
 501 {
 502         u64 async_event_mask = MLX5_ASYNC_EVENT_MASK;
 503
 504         if (MLX5_VPORT_MANAGER(dev))
 505                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_NIC_VPORT_CHANGE);
 506
 507         if (MLX5_CAP_GEN(dev, port_type) == MLX5_CAP_PORT_TYPE_ETH &&
 508             MLX5_CAP_GEN(dev, general_notification_event))
 509                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_GENERAL_EVENT);
 510
 511         if (MLX5_CAP_GEN(dev, port_module_event))
 512                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_PORT_MODULE_EVENT);
 513         else
 514                 mlx5_core_dbg(dev, "port_module_event is not set\n");
 515
 516         if (MLX5_PPS_CAP(dev))
 517                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_PPS_EVENT);
 518
 519         if (MLX5_CAP_GEN(dev, fpga))
 520                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_FPGA_ERROR) |
 521                                     (1ull << MLX5_EVENT_TYPE_FPGA_QP_ERROR);
 522         if (MLX5_CAP_GEN_MAX(dev, dct))
 523                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_DCT_DRAINED);
 524
 525         if (MLX5_CAP_GEN(dev, temp_warn_event))
 526                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_TEMP_WARN_EVENT);
 527
 528         if (MLX5_CAP_MCAM_REG(dev, tracer_registers))
 529                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_DEVICE_TRACER);
 530
 531         if (MLX5_CAP_GEN(dev, max_num_of_monitor_counters))
 532                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_MONITOR_COUNTER);
 533
 534         if (mlx5_core_is_ecpf_esw_manager(dev))
 535                 async_event_mask |= (1ull << MLX5_EVENT_TYPE_HOST_PARAMS_CHANGE);
 536
 537         return async_event_mask;
 538 }
 539
 540 static int create_async_eqs(struct mlx5_core_dev *dev)
 541 {
 542         struct mlx5_eq_table *table = dev->priv.eq_table;
 543         struct mlx5_eq_param param = {};
 544         int err;
 545
 546         MLX5_NB_INIT(&table->cq_err_nb, cq_err_event_notifier, CQ_ERROR);
 547         mlx5_eq_notifier_register(dev, &table->cq_err_nb);
 548
 549         param = (struct mlx5_eq_param) {
 550                 .index = MLX5_EQ_CMD_IDX,
 551                 .mask = 1ull << MLX5_EVENT_TYPE_CMD,
 552                 .nent = MLX5_NUM_CMD_EQE,
 553                 .context = &table->cmd_eq,
 554                 .handler = mlx5_eq_async_int,
 555         };
 556         err = create_async_eq(dev, "mlx5_cmd_eq", &table->cmd_eq, &param);
 557         if (err) {
 558                 mlx5_core_warn(dev, "failed to create cmd EQ %d\n", err);
 559                 goto err0;
 560         }
 561
 562         mlx5_cmd_use_events(dev);
 563
 564         param = (struct mlx5_eq_param) {
 565                 .index = MLX5_EQ_ASYNC_IDX,
 566                 .mask = gather_async_events_mask(dev),
 567                 .nent = MLX5_NUM_ASYNC_EQE,
 568                 .context = &table->async_eq,
 569                 .handler = mlx5_eq_async_int,
 570         };
 571         err = create_async_eq(dev, "mlx5_async_eq", &table->async_eq, &param);
 572         if (err) {
 573                 mlx5_core_warn(dev, "failed to create async EQ %d\n", err);
 574                 goto err1;
 575         }
 576
 577         param = (struct mlx5_eq_param) {
 578                 .index = MLX5_EQ_PAGEREQ_IDX,
 579                 .mask =  1 << MLX5_EVENT_TYPE_PAGE_REQUEST,
 580                 .nent = /* TODO: sriov max_vf + */ 1,
 581                 .context = &table->pages_eq,
 582                 .handler = mlx5_eq_async_int,
 583         };
 584         err = create_async_eq(dev, "mlx5_pages_eq", &table->pages_eq, &param);
 585         if (err) {
 586                 mlx5_core_warn(dev, "failed to create pages EQ %d\n", err);
 587                 goto err2;
 588         }
 589
 590         return err;
 591
 592 err2:
 593         destroy_async_eq(dev, &table->async_eq);
 594
 595 err1:
 596         mlx5_cmd_use_polling(dev);
 597         destroy_async_eq(dev, &table->cmd_eq);
 598 err0:
 599         mlx5_eq_notifier_unregister(dev, &table->cq_err_nb);
 600         return err;
 601 }
 602
 603 static void destroy_async_eqs(struct mlx5_core_dev *dev)
 604 {
 605         struct mlx5_eq_table *table = dev->priv.eq_table;
 606         int err;
 607
 608         err = destroy_async_eq(dev, &table->pages_eq);
 609         if (err)
 610                 mlx5_core_err(dev, "failed to destroy pages eq, err(%d)\n",
 611                               err);
 612
 613         err = destroy_async_eq(dev, &table->async_eq);
 614         if (err)
 615                 mlx5_core_err(dev, "failed to destroy async eq, err(%d)\n",
 616                               err);
 617
 618         mlx5_cmd_use_polling(dev);
 619
 620         err = destroy_async_eq(dev, &table->cmd_eq);
 621         if (err)
 622                 mlx5_core_err(dev, "failed to destroy command eq, err(%d)\n",
 623                               err);
 624
 625         mlx5_eq_notifier_unregister(dev, &table->cq_err_nb);
 626 }
 627
 628 struct mlx5_eq *mlx5_get_async_eq(struct mlx5_core_dev *dev)
 629 {
 630         return &dev->priv.eq_table->async_eq;
 631 }
 632
 633 void mlx5_eq_synchronize_async_irq(struct mlx5_core_dev *dev)
 634 {
 635         synchronize_irq(dev->priv.eq_table->async_eq.irqn);
 636 }
 637
 638 void mlx5_eq_synchronize_cmd_irq(struct mlx5_core_dev *dev)
 639 {
 640         synchronize_irq(dev->priv.eq_table->cmd_eq.irqn);
 641 }
 642
 643 /* Generic EQ API for mlx5_core consumers
 644  * Needed For RDMA ODP EQ for now
 645  */
 646 struct mlx5_eq *
 647 mlx5_eq_create_generic(struct mlx5_core_dev *dev, const char *name,
 648                        struct mlx5_eq_param *param)
 649 {
 650         struct mlx5_eq *eq = kvzalloc(sizeof(*eq), GFP_KERNEL);
 651         int err;
 652
 653         if (!eq)
 654                 return ERR_PTR(-ENOMEM);
 655
 656         err = create_async_eq(dev, name, eq, param);
 657         if (err) {
 658                 kvfree(eq);
 659                 eq = ERR_PTR(err);
 660         }
 661
 662         return eq;
 663 }
 664 EXPORT_SYMBOL(mlx5_eq_create_generic);
 665
 666 int mlx5_eq_destroy_generic(struct mlx5_core_dev *dev, struct mlx5_eq *eq)
 667 {
 668         int err;
 669
 670         if (IS_ERR(eq))
 671                 return -EINVAL;
 672
 673         err = destroy_async_eq(dev, eq);
 674         if (err)
 675                 goto out;
 676
 677         kvfree(eq);
 678 out:
 679         return err;
 680 }
 681 EXPORT_SYMBOL(mlx5_eq_destroy_generic);
 682
 683 struct mlx5_eqe *mlx5_eq_get_eqe(struct mlx5_eq *eq, u32 cc)
 684 {
 685         u32 ci = eq->cons_index + cc;
 686         struct mlx5_eqe *eqe;
 687
 688         eqe = get_eqe(eq, ci & (eq->nent - 1));
 689         eqe = ((eqe->owner & 1) ^ !!(ci & eq->nent)) ? NULL : eqe;
 690         /* Make sure we read EQ entry contents after we've
 691          * checked the ownership bit.
 692          */
 693         if (eqe)
 694                 dma_rmb();
 695
 696         return eqe;
 697 }
 698 EXPORT_SYMBOL(mlx5_eq_get_eqe);
 699
 700 void mlx5_eq_update_ci(struct mlx5_eq *eq, u32 cc, bool arm)
 701 {
 702         __be32 __iomem *addr = eq->doorbell + (arm ? 0 : 2);
 703         u32 val;
 704
 705         eq->cons_index += cc;
 706         val = (eq->cons_index & 0xffffff) | (eq->eqn << 24);
 707
 708         __raw_writel((__force u32)cpu_to_be32(val), addr);
 709         /* We still want ordering, just not swabbing, so add a barrier */
 710         mb();
 711 }
 712 EXPORT_SYMBOL(mlx5_eq_update_ci);
 713
 714 /* Completion EQs */
 715
 716 static int set_comp_irq_affinity_hint(struct mlx5_core_dev *mdev, int i)
 717 {
 718         struct mlx5_priv *priv  = &mdev->priv;
 719         int vecidx = MLX5_EQ_VEC_COMP_BASE + i;
 720         int irq = pci_irq_vector(mdev->pdev, vecidx);
 721         struct mlx5_irq_info *irq_info = &priv->eq_table->irq_info[vecidx];
 722
 723         if (!zalloc_cpumask_var(&irq_info->mask, GFP_KERNEL)) {
 724                 mlx5_core_warn(mdev, "zalloc_cpumask_var failed");
 725                 return -ENOMEM;
 726         }
 727
 728         cpumask_set_cpu(cpumask_local_spread(i, priv->numa_node),
 729                         irq_info->mask);
 730
 731         if (IS_ENABLED(CONFIG_SMP) &&
 732             irq_set_affinity_hint(irq, irq_info->mask))
 733                 mlx5_core_warn(mdev, "irq_set_affinity_hint failed, irq 0x%.4x", irq);
 734
 735         return 0;
 736 }
 737
 738 static void clear_comp_irq_affinity_hint(struct mlx5_core_dev *mdev, int i)
 739 {
 740         int vecidx = MLX5_EQ_VEC_COMP_BASE + i;
 741         struct mlx5_priv *priv  = &mdev->priv;
 742         int irq = pci_irq_vector(mdev->pdev, vecidx);
 743         struct mlx5_irq_info *irq_info = &priv->eq_table->irq_info[vecidx];
 744
 745         irq_set_affinity_hint(irq, NULL);
 746         free_cpumask_var(irq_info->mask);
 747 }
 748
 749 static int set_comp_irq_affinity_hints(struct mlx5_core_dev *mdev)
 750 {
 751         int err;
 752         int i;
 753
 754         for (i = 0; i < mdev->priv.eq_table->num_comp_vectors; i++) {
 755                 err = set_comp_irq_affinity_hint(mdev, i);
 756                 if (err)
 757                         goto err_out;
 758         }
 759
 760         return 0;
 761
 762 err_out:
 763         for (i--; i >= 0; i--)
 764                 clear_comp_irq_affinity_hint(mdev, i);
 765
 766         return err;
 767 }
 768
 769 static void clear_comp_irqs_affinity_hints(struct mlx5_core_dev *mdev)
 770 {
 771         int i;
 772
 773         for (i = 0; i < mdev->priv.eq_table->num_comp_vectors; i++)
 774                 clear_comp_irq_affinity_hint(mdev, i);
 775 }
 776
 777 static void destroy_comp_eqs(struct mlx5_core_dev *dev)
 778 {
 779         struct mlx5_eq_table *table = dev->priv.eq_table;
 780         struct mlx5_eq_comp *eq, *n;
 781
 782         clear_comp_irqs_affinity_hints(dev);
 783
 784 #ifdef CONFIG_RFS_ACCEL
 785         if (table->rmap) {
 786                 free_irq_cpu_rmap(table->rmap);
 787                 table->rmap = NULL;
 788         }
 789 #endif
 790         list_for_each_entry_safe(eq, n, &table->comp_eqs_list, list) {
 791                 list_del(&eq->list);
 792                 if (destroy_unmap_eq(dev, &eq->core))
 793                         mlx5_core_warn(dev, "failed to destroy comp EQ 0x%x\n",
 794                                        eq->core.eqn);
 795                 tasklet_disable(&eq->tasklet_ctx.task);
 796                 kfree(eq);
 797         }
 798 }
 799
 800 static int create_comp_eqs(struct mlx5_core_dev *dev)
 801 {
 802         struct mlx5_eq_table *table = dev->priv.eq_table;
 803         char name[MLX5_MAX_IRQ_NAME];
 804         struct mlx5_eq_comp *eq;
 805         int ncomp_vec;
 806         int nent;
 807         int err;
 808         int i;
 809
 810         INIT_LIST_HEAD(&table->comp_eqs_list);
 811         ncomp_vec = table->num_comp_vectors;
 812         nent = MLX5_COMP_EQ_SIZE;
 813 #ifdef CONFIG_RFS_ACCEL
 814         table->rmap = alloc_irq_cpu_rmap(ncomp_vec);
 815         if (!table->rmap)
 816                 return -ENOMEM;
 817 #endif
 818         for (i = 0; i < ncomp_vec; i++) {
 819                 int vecidx = i + MLX5_EQ_VEC_COMP_BASE;
 820                 struct mlx5_eq_param param = {};
 821
 822                 eq = kzalloc(sizeof(*eq), GFP_KERNEL);
 823                 if (!eq) {
 824                         err = -ENOMEM;
 825                         goto clean;
 826                 }
 827
 828                 INIT_LIST_HEAD(&eq->tasklet_ctx.list);
 829                 INIT_LIST_HEAD(&eq->tasklet_ctx.process_list);
 830                 spin_lock_init(&eq->tasklet_ctx.lock);
 831                 tasklet_init(&eq->tasklet_ctx.task, mlx5_cq_tasklet_cb,
 832                              (unsigned long)&eq->tasklet_ctx);
 833
 834 #ifdef CONFIG_RFS_ACCEL
 835                 irq_cpu_rmap_add(table->rmap, pci_irq_vector(dev->pdev, vecidx));
 836 #endif
 837                 snprintf(name, MLX5_MAX_IRQ_NAME, "mlx5_comp%d", i);
 838                 param = (struct mlx5_eq_param) {
 839                         .index = vecidx,
 840                         .mask = 0,
 841                         .nent = nent,
 842                         .context = &eq->core,
 843                         .handler = mlx5_eq_comp_int
 844                 };
 845                 err = create_map_eq(dev, &eq->core, name, &param);
 846                 if (err) {
 847                         kfree(eq);
 848                         goto clean;
 849                 }
 850                 mlx5_core_dbg(dev, "allocated completion EQN %d\n", eq->core.eqn);
 851                 /* add tail, to keep the list ordered, for mlx5_vector2eqn to work */
 852                 list_add_tail(&eq->list, &table->comp_eqs_list);
 853         }
 854
 855         err = set_comp_irq_affinity_hints(dev);
 856         if (err) {
 857                 mlx5_core_err(dev, "Failed to alloc affinity hint cpumask\n");
 858                 goto clean;
 859         }
 860
 861         return 0;
 862
 863 clean:
 864         destroy_comp_eqs(dev);
 865         return err;
 866 }
 867
 868 int mlx5_vector2eqn(struct mlx5_core_dev *dev, int vector, int *eqn,
 869                     unsigned int *irqn)
 870 {
 871         struct mlx5_eq_table *table = dev->priv.eq_table;
 872         struct mlx5_eq_comp *eq, *n;
 873         int err = -ENOENT;
 874         int i = 0;
 875
 876         list_for_each_entry_safe(eq, n, &table->comp_eqs_list, list) {
 877                 if (i++ == vector) {
 878                         *eqn = eq->core.eqn;
 879                         *irqn = eq->core.irqn;
 880                         err = 0;
 881                         break;
 882                 }
 883         }
 884
 885         return err;
 886 }
 887 EXPORT_SYMBOL(mlx5_vector2eqn);
 888
 889 unsigned int mlx5_comp_vectors_count(struct mlx5_core_dev *dev)
 890 {
 891         return dev->priv.eq_table->num_comp_vectors;
 892 }
 893 EXPORT_SYMBOL(mlx5_comp_vectors_count);
 894
 895 struct cpumask *
 896 mlx5_comp_irq_get_affinity_mask(struct mlx5_core_dev *dev, int vector)
 897 {
 898         /* TODO: consider irq_get_affinity_mask(irq) */
 899         return dev->priv.eq_table->irq_info[vector + MLX5_EQ_VEC_COMP_BASE].mask;
 900 }
 901 EXPORT_SYMBOL(mlx5_comp_irq_get_affinity_mask);
 902
 903 struct cpu_rmap *mlx5_eq_table_get_rmap(struct mlx5_core_dev *dev)
 904 {
 905 #ifdef CONFIG_RFS_ACCEL
 906         return dev->priv.eq_table->rmap;
 907 #else
 908         return NULL;
 909 #endif
 910 }
 911
 912 struct mlx5_eq_comp *mlx5_eqn2comp_eq(struct mlx5_core_dev *dev, int eqn)
 913 {
 914         struct mlx5_eq_table *table = dev->priv.eq_table;
 915         struct mlx5_eq_comp *eq;
 916
 917         list_for_each_entry(eq, &table->comp_eqs_list, list) {
 918                 if (eq->core.eqn == eqn)
 919                         return eq;
 920         }
 921
 922         return ERR_PTR(-ENOENT);
 923 }
 924
 925 /* This function should only be called after mlx5_cmd_force_teardown_hca */
 926 void mlx5_core_eq_free_irqs(struct mlx5_core_dev *dev)
 927 {
 928         struct mlx5_eq_table *table = dev->priv.eq_table;
 929         int i, max_eqs;
 930
 931         clear_comp_irqs_affinity_hints(dev);
 932
 933 #ifdef CONFIG_RFS_ACCEL
 934         if (table->rmap) {
 935                 free_irq_cpu_rmap(table->rmap);
 936                 table->rmap = NULL;
 937         }
 938 #endif
 939
 940         mutex_lock(&table->lock); /* sync with create/destroy_async_eq */
 941         max_eqs = table->num_comp_vectors + MLX5_EQ_VEC_COMP_BASE;
 942         for (i = max_eqs - 1; i >= 0; i--) {
 943                 if (!table->irq_info[i].context)
 944                         continue;
 945                 free_irq(pci_irq_vector(dev->pdev, i), table->irq_info[i].context);
 946                 table->irq_info[i].context = NULL;
 947         }
 948         mutex_unlock(&table->lock);
 949         pci_free_irq_vectors(dev->pdev);
 950 }
 951
 952 static int alloc_irq_vectors(struct mlx5_core_dev *dev)
 953 {
 954         struct mlx5_priv *priv = &dev->priv;
 955         struct mlx5_eq_table *table = priv->eq_table;
 956         int num_eqs = MLX5_CAP_GEN(dev, max_num_eqs) ?
 957                       MLX5_CAP_GEN(dev, max_num_eqs) :
 958                       1 << MLX5_CAP_GEN(dev, log_max_eq);
 959         int nvec;
 960         int err;
 961
 962         nvec = MLX5_CAP_GEN(dev, num_ports) * num_online_cpus() +
 963                MLX5_EQ_VEC_COMP_BASE;
 964         nvec = min_t(int, nvec, num_eqs);
 965         if (nvec <= MLX5_EQ_VEC_COMP_BASE)
 966                 return -ENOMEM;
 967
 968         table->irq_info = kcalloc(nvec, sizeof(*table->irq_info), GFP_KERNEL);
 969         if (!table->irq_info)
 970                 return -ENOMEM;
 971
 972         nvec = pci_alloc_irq_vectors(dev->pdev, MLX5_EQ_VEC_COMP_BASE + 1,
 973                                      nvec, PCI_IRQ_MSIX);
 974         if (nvec < 0) {
 975                 err = nvec;
 976                 goto err_free_irq_info;
 977         }
 978
 979         table->num_comp_vectors = nvec - MLX5_EQ_VEC_COMP_BASE;
 980
 981         return 0;
 982
 983 err_free_irq_info:
 984         kfree(table->irq_info);
 985         return err;
 986 }
 987
 988 static void free_irq_vectors(struct mlx5_core_dev *dev)
 989 {
 990         struct mlx5_priv *priv = &dev->priv;
 991
 992         pci_free_irq_vectors(dev->pdev);
 993         kfree(priv->eq_table->irq_info);
 994 }
 995
 996 int mlx5_eq_table_create(struct mlx5_core_dev *dev)
 997 {
 998         int err;
 999
1000         err = alloc_irq_vectors(dev);
1001         if (err) {
1002                 mlx5_core_err(dev, "alloc irq vectors failed\n");
1003                 return err;
1004         }
1005
1006         err = create_async_eqs(dev);
1007         if (err) {
1008                 mlx5_core_err(dev, "Failed to create async EQs\n");
1009                 goto err_async_eqs;
1010         }
1011
1012         err = create_comp_eqs(dev);
1013         if (err) {
1014                 mlx5_core_err(dev, "Failed to create completion EQs\n");
1015                 goto err_comp_eqs;
1016         }
1017
1018         return 0;
1019 err_comp_eqs:
1020         destroy_async_eqs(dev);
1021 err_async_eqs:
1022         free_irq_vectors(dev);
1023         return err;
1024 }
1025
1026 void mlx5_eq_table_destroy(struct mlx5_core_dev *dev)
1027 {
1028         destroy_comp_eqs(dev);
1029         destroy_async_eqs(dev);
1030         free_irq_vectors(dev);
1031 }
1032
1033 int mlx5_eq_notifier_register(struct mlx5_core_dev *dev, struct mlx5_nb *nb)
1034 {
1035         struct mlx5_eq_table *eqt = dev->priv.eq_table;
1036
1037         if (nb->event_type >= MLX5_EVENT_TYPE_MAX)
1038                 return -EINVAL;
1039
1040         return atomic_notifier_chain_register(&eqt->nh[nb->event_type], &nb->nb);
1041 }
1042
1043 int mlx5_eq_notifier_unregister(struct mlx5_core_dev *dev, struct mlx5_nb *nb)
1044 {
1045         struct mlx5_eq_table *eqt = dev->priv.eq_table;
1046
1047         if (nb->event_type >= MLX5_EVENT_TYPE_MAX)
1048                 return -EINVAL;
1049
1050         return atomic_notifier_chain_unregister(&eqt->nh[nb->event_type], &nb->nb);
1051 }