drivers/net/ethernet/mellanox/mlx4/resource_tracker.c

   1 /*
   2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
   3  * Copyright (c) 2005, 2006, 2007, 2008 Mellanox Technologies.
   4  * All rights reserved.
   5  * Copyright (c) 2005, 2006, 2007 Cisco Systems, Inc.  All rights reserved.
   6  *
   7  * This software is available to you under a choice of one of two
   8  * licenses.  You may choose to be licensed under the terms of the GNU
   9  * General Public License (GPL) Version 2, available from the file
  10  * COPYING in the main directory of this source tree, or the
  11  * OpenIB.org BSD license below:
  12  *
  13  *     Redistribution and use in source and binary forms, with or
  14  *     without modification, are permitted provided that the following
  15  *     conditions are met:
  16  *
  17  *      - Redistributions of source code must retain the above
  18  *        copyright notice, this list of conditions and the following
  19  *        disclaimer.
  20  *
  21  *      - Redistributions in binary form must reproduce the above
  22  *        copyright notice, this list of conditions and the following
  23  *        disclaimer in the documentation and/or other materials
  24  *        provided with the distribution.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33  * SOFTWARE.
  34  */
  35
  36 #include <linux/sched.h>
  37 #include <linux/pci.h>
  38 #include <linux/errno.h>
  39 #include <linux/kernel.h>
  40 #include <linux/io.h>
  41 #include <linux/slab.h>
  42 #include <linux/mlx4/cmd.h>
  43 #include <linux/mlx4/qp.h>
  44 #include <linux/if_ether.h>
  45
  46 #include "mlx4.h"
  47 #include "fw.h"
  48
  49 #define MLX4_MAC_VALID          (1ull << 63)
  50
  51 struct mac_res {
  52         struct list_head list;
  53         u64 mac;
  54         u8 port;
  55 };
  56
  57 struct res_common {
  58         struct list_head        list;
  59         struct rb_node          node;
  60         u64                     res_id;
  61         int                     owner;
  62         int                     state;
  63         int                     from_state;
  64         int                     to_state;
  65         int                     removing;
  66 };
  67
  68 enum {
  69         RES_ANY_BUSY = 1
  70 };
  71
  72 struct res_gid {
  73         struct list_head        list;
  74         u8                      gid[16];
  75         enum mlx4_protocol      prot;
  76         enum mlx4_steer_type    steer;
  77 };
  78
  79 enum res_qp_states {
  80         RES_QP_BUSY = RES_ANY_BUSY,
  81
  82         /* QP number was allocated */
  83         RES_QP_RESERVED,
  84
  85         /* ICM memory for QP context was mapped */
  86         RES_QP_MAPPED,
  87
  88         /* QP is in hw ownership */
  89         RES_QP_HW
  90 };
  91
  92 struct res_qp {
  93         struct res_common       com;
  94         struct res_mtt         *mtt;
  95         struct res_cq          *rcq;
  96         struct res_cq          *scq;
  97         struct res_srq         *srq;
  98         struct list_head        mcg_list;
  99         spinlock_t              mcg_spl;
 100         int                     local_qpn;
 101 };
 102
 103 enum res_mtt_states {
 104         RES_MTT_BUSY = RES_ANY_BUSY,
 105         RES_MTT_ALLOCATED,
 106 };
 107
 108 static inline const char *mtt_states_str(enum res_mtt_states state)
 109 {
 110         switch (state) {
 111         case RES_MTT_BUSY: return "RES_MTT_BUSY";
 112         case RES_MTT_ALLOCATED: return "RES_MTT_ALLOCATED";
 113         default: return "Unknown";
 114         }
 115 }
 116
 117 struct res_mtt {
 118         struct res_common       com;
 119         int                     order;
 120         atomic_t                ref_count;
 121 };
 122
 123 enum res_mpt_states {
 124         RES_MPT_BUSY = RES_ANY_BUSY,
 125         RES_MPT_RESERVED,
 126         RES_MPT_MAPPED,
 127         RES_MPT_HW,
 128 };
 129
 130 struct res_mpt {
 131         struct res_common       com;
 132         struct res_mtt         *mtt;
 133         int                     key;
 134 };
 135
 136 enum res_eq_states {
 137         RES_EQ_BUSY = RES_ANY_BUSY,
 138         RES_EQ_RESERVED,
 139         RES_EQ_HW,
 140 };
 141
 142 struct res_eq {
 143         struct res_common       com;
 144         struct res_mtt         *mtt;
 145 };
 146
 147 enum res_cq_states {
 148         RES_CQ_BUSY = RES_ANY_BUSY,
 149         RES_CQ_ALLOCATED,
 150         RES_CQ_HW,
 151 };
 152
 153 struct res_cq {
 154         struct res_common       com;
 155         struct res_mtt         *mtt;
 156         atomic_t                ref_count;
 157 };
 158
 159 enum res_srq_states {
 160         RES_SRQ_BUSY = RES_ANY_BUSY,
 161         RES_SRQ_ALLOCATED,
 162         RES_SRQ_HW,
 163 };
 164
 165 struct res_srq {
 166         struct res_common       com;
 167         struct res_mtt         *mtt;
 168         struct res_cq          *cq;
 169         atomic_t                ref_count;
 170 };
 171
 172 enum res_counter_states {
 173         RES_COUNTER_BUSY = RES_ANY_BUSY,
 174         RES_COUNTER_ALLOCATED,
 175 };
 176
 177 struct res_counter {
 178         struct res_common       com;
 179         int                     port;
 180 };
 181
 182 enum res_xrcdn_states {
 183         RES_XRCD_BUSY = RES_ANY_BUSY,
 184         RES_XRCD_ALLOCATED,
 185 };
 186
 187 struct res_xrcdn {
 188         struct res_common       com;
 189         int                     port;
 190 };
 191
 192 enum res_fs_rule_states {
 193         RES_FS_RULE_BUSY = RES_ANY_BUSY,
 194         RES_FS_RULE_ALLOCATED,
 195 };
 196
 197 struct res_fs_rule {
 198         struct res_common       com;
 199 };
 200
 201 static void *res_tracker_lookup(struct rb_root *root, u64 res_id)
 202 {
 203         struct rb_node *node = root->rb_node;
 204
 205         while (node) {
 206                 struct res_common *res = container_of(node, struct res_common,
 207                                                       node);
 208
 209                 if (res_id < res->res_id)
 210                         node = node->rb_left;
 211                 else if (res_id > res->res_id)
 212                         node = node->rb_right;
 213                 else
 214                         return res;
 215         }
 216         return NULL;
 217 }
 218
 219 static int res_tracker_insert(struct rb_root *root, struct res_common *res)
 220 {
 221         struct rb_node **new = &(root->rb_node), *parent = NULL;
 222
 223         /* Figure out where to put new node */
 224         while (*new) {
 225                 struct res_common *this = container_of(*new, struct res_common,
 226                                                        node);
 227
 228                 parent = *new;
 229                 if (res->res_id < this->res_id)
 230                         new = &((*new)->rb_left);
 231                 else if (res->res_id > this->res_id)
 232                         new = &((*new)->rb_right);
 233                 else
 234                         return -EEXIST;
 235         }
 236
 237         /* Add new node and rebalance tree. */
 238         rb_link_node(&res->node, parent, new);
 239         rb_insert_color(&res->node, root);
 240
 241         return 0;
 242 }
 243
 244 /* For Debug uses */
 245 static const char *ResourceType(enum mlx4_resource rt)
 246 {
 247         switch (rt) {
 248         case RES_QP: return "RES_QP";
 249         case RES_CQ: return "RES_CQ";
 250         case RES_SRQ: return "RES_SRQ";
 251         case RES_MPT: return "RES_MPT";
 252         case RES_MTT: return "RES_MTT";
 253         case RES_MAC: return  "RES_MAC";
 254         case RES_EQ: return "RES_EQ";
 255         case RES_COUNTER: return "RES_COUNTER";
 256         case RES_FS_RULE: return "RES_FS_RULE";
 257         case RES_XRCD: return "RES_XRCD";
 258         default: return "Unknown resource type !!!";
 259         };
 260 }
 261
 262 int mlx4_init_resource_tracker(struct mlx4_dev *dev)
 263 {
 264         struct mlx4_priv *priv = mlx4_priv(dev);
 265         int i;
 266         int t;
 267
 268         priv->mfunc.master.res_tracker.slave_list =
 269                 kzalloc(dev->num_slaves * sizeof(struct slave_list),
 270                         GFP_KERNEL);
 271         if (!priv->mfunc.master.res_tracker.slave_list)
 272                 return -ENOMEM;
 273
 274         for (i = 0 ; i < dev->num_slaves; i++) {
 275                 for (t = 0; t < MLX4_NUM_OF_RESOURCE_TYPE; ++t)
 276                         INIT_LIST_HEAD(&priv->mfunc.master.res_tracker.
 277                                        slave_list[i].res_list[t]);
 278                 mutex_init(&priv->mfunc.master.res_tracker.slave_list[i].mutex);
 279         }
 280
 281         mlx4_dbg(dev, "Started init_resource_tracker: %ld slaves\n",
 282                  dev->num_slaves);
 283         for (i = 0 ; i < MLX4_NUM_OF_RESOURCE_TYPE; i++)
 284                 priv->mfunc.master.res_tracker.res_tree[i] = RB_ROOT;
 285
 286         spin_lock_init(&priv->mfunc.master.res_tracker.lock);
 287         return 0 ;
 288 }
 289
 290 void mlx4_free_resource_tracker(struct mlx4_dev *dev,
 291                                 enum mlx4_res_tracker_free_type type)
 292 {
 293         struct mlx4_priv *priv = mlx4_priv(dev);
 294         int i;
 295
 296         if (priv->mfunc.master.res_tracker.slave_list) {
 297                 if (type != RES_TR_FREE_STRUCTS_ONLY)
 298                         for (i = 0 ; i < dev->num_slaves; i++)
 299                                 if (type == RES_TR_FREE_ALL ||
 300                                     dev->caps.function != i)
 301                                         mlx4_delete_all_resources_for_slave(dev, i);
 302
 303                 if (type != RES_TR_FREE_SLAVES_ONLY) {
 304                         kfree(priv->mfunc.master.res_tracker.slave_list);
 305                         priv->mfunc.master.res_tracker.slave_list = NULL;
 306                 }
 307         }
 308 }
 309
 310 static void update_ud_gid(struct mlx4_dev *dev,
 311                           struct mlx4_qp_context *qp_ctx, u8 slave)
 312 {
 313         u32 ts = (be32_to_cpu(qp_ctx->flags) >> 16) & 0xff;
 314
 315         if (MLX4_QP_ST_UD == ts)
 316                 qp_ctx->pri_path.mgid_index = 0x80 | slave;
 317
 318         mlx4_dbg(dev, "slave %d, new gid index: 0x%x ",
 319                 slave, qp_ctx->pri_path.mgid_index);
 320 }
 321
 322 static int mpt_mask(struct mlx4_dev *dev)
 323 {
 324         return dev->caps.num_mpts - 1;
 325 }
 326
 327 static void *find_res(struct mlx4_dev *dev, int res_id,
 328                       enum mlx4_resource type)
 329 {
 330         struct mlx4_priv *priv = mlx4_priv(dev);
 331
 332         return res_tracker_lookup(&priv->mfunc.master.res_tracker.res_tree[type],
 333                                   res_id);
 334 }
 335
 336 static int get_res(struct mlx4_dev *dev, int slave, u64 res_id,
 337                    enum mlx4_resource type,
 338                    void *res)
 339 {
 340         struct res_common *r;
 341         int err = 0;
 342
 343         spin_lock_irq(mlx4_tlock(dev));
 344         r = find_res(dev, res_id, type);
 345         if (!r) {
 346                 err = -ENONET;
 347                 goto exit;
 348         }
 349
 350         if (r->state == RES_ANY_BUSY) {
 351                 err = -EBUSY;
 352                 goto exit;
 353         }
 354
 355         if (r->owner != slave) {
 356                 err = -EPERM;
 357                 goto exit;
 358         }
 359
 360         r->from_state = r->state;
 361         r->state = RES_ANY_BUSY;
 362         mlx4_dbg(dev, "res %s id 0x%llx to busy\n",
 363                  ResourceType(type), r->res_id);
 364
 365         if (res)
 366                 *((struct res_common **)res) = r;
 367
 368 exit:
 369         spin_unlock_irq(mlx4_tlock(dev));
 370         return err;
 371 }
 372
 373 int mlx4_get_slave_from_resource_id(struct mlx4_dev *dev,
 374                                     enum mlx4_resource type,
 375                                     u64 res_id, int *slave)
 376 {
 377
 378         struct res_common *r;
 379         int err = -ENOENT;
 380         int id = res_id;
 381
 382         if (type == RES_QP)
 383                 id &= 0x7fffff;
 384         spin_lock(mlx4_tlock(dev));
 385
 386         r = find_res(dev, id, type);
 387         if (r) {
 388                 *slave = r->owner;
 389                 err = 0;
 390         }
 391         spin_unlock(mlx4_tlock(dev));
 392
 393         return err;
 394 }
 395
 396 static void put_res(struct mlx4_dev *dev, int slave, u64 res_id,
 397                     enum mlx4_resource type)
 398 {
 399         struct res_common *r;
 400
 401         spin_lock_irq(mlx4_tlock(dev));
 402         r = find_res(dev, res_id, type);
 403         if (r)
 404                 r->state = r->from_state;
 405         spin_unlock_irq(mlx4_tlock(dev));
 406 }
 407
 408 static struct res_common *alloc_qp_tr(int id)
 409 {
 410         struct res_qp *ret;
 411
 412         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 413         if (!ret)
 414                 return NULL;
 415
 416         ret->com.res_id = id;
 417         ret->com.state = RES_QP_RESERVED;
 418         ret->local_qpn = id;
 419         INIT_LIST_HEAD(&ret->mcg_list);
 420         spin_lock_init(&ret->mcg_spl);
 421
 422         return &ret->com;
 423 }
 424
 425 static struct res_common *alloc_mtt_tr(int id, int order)
 426 {
 427         struct res_mtt *ret;
 428
 429         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 430         if (!ret)
 431                 return NULL;
 432
 433         ret->com.res_id = id;
 434         ret->order = order;
 435         ret->com.state = RES_MTT_ALLOCATED;
 436         atomic_set(&ret->ref_count, 0);
 437
 438         return &ret->com;
 439 }
 440
 441 static struct res_common *alloc_mpt_tr(int id, int key)
 442 {
 443         struct res_mpt *ret;
 444
 445         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 446         if (!ret)
 447                 return NULL;
 448
 449         ret->com.res_id = id;
 450         ret->com.state = RES_MPT_RESERVED;
 451         ret->key = key;
 452
 453         return &ret->com;
 454 }
 455
 456 static struct res_common *alloc_eq_tr(int id)
 457 {
 458         struct res_eq *ret;
 459
 460         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 461         if (!ret)
 462                 return NULL;
 463
 464         ret->com.res_id = id;
 465         ret->com.state = RES_EQ_RESERVED;
 466
 467         return &ret->com;
 468 }
 469
 470 static struct res_common *alloc_cq_tr(int id)
 471 {
 472         struct res_cq *ret;
 473
 474         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 475         if (!ret)
 476                 return NULL;
 477
 478         ret->com.res_id = id;
 479         ret->com.state = RES_CQ_ALLOCATED;
 480         atomic_set(&ret->ref_count, 0);
 481
 482         return &ret->com;
 483 }
 484
 485 static struct res_common *alloc_srq_tr(int id)
 486 {
 487         struct res_srq *ret;
 488
 489         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 490         if (!ret)
 491                 return NULL;
 492
 493         ret->com.res_id = id;
 494         ret->com.state = RES_SRQ_ALLOCATED;
 495         atomic_set(&ret->ref_count, 0);
 496
 497         return &ret->com;
 498 }
 499
 500 static struct res_common *alloc_counter_tr(int id)
 501 {
 502         struct res_counter *ret;
 503
 504         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 505         if (!ret)
 506                 return NULL;
 507
 508         ret->com.res_id = id;
 509         ret->com.state = RES_COUNTER_ALLOCATED;
 510
 511         return &ret->com;
 512 }
 513
 514 static struct res_common *alloc_xrcdn_tr(int id)
 515 {
 516         struct res_xrcdn *ret;
 517
 518         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 519         if (!ret)
 520                 return NULL;
 521
 522         ret->com.res_id = id;
 523         ret->com.state = RES_XRCD_ALLOCATED;
 524
 525         return &ret->com;
 526 }
 527
 528 static struct res_common *alloc_fs_rule_tr(u64 id)
 529 {
 530         struct res_fs_rule *ret;
 531
 532         ret = kzalloc(sizeof *ret, GFP_KERNEL);
 533         if (!ret)
 534                 return NULL;
 535
 536         ret->com.res_id = id;
 537         ret->com.state = RES_FS_RULE_ALLOCATED;
 538
 539         return &ret->com;
 540 }
 541
 542 static struct res_common *alloc_tr(u64 id, enum mlx4_resource type, int slave,
 543                                    int extra)
 544 {
 545         struct res_common *ret;
 546
 547         switch (type) {
 548         case RES_QP:
 549                 ret = alloc_qp_tr(id);
 550                 break;
 551         case RES_MPT:
 552                 ret = alloc_mpt_tr(id, extra);
 553                 break;
 554         case RES_MTT:
 555                 ret = alloc_mtt_tr(id, extra);
 556                 break;
 557         case RES_EQ:
 558                 ret = alloc_eq_tr(id);
 559                 break;
 560         case RES_CQ:
 561                 ret = alloc_cq_tr(id);
 562                 break;
 563         case RES_SRQ:
 564                 ret = alloc_srq_tr(id);
 565                 break;
 566         case RES_MAC:
 567                 printk(KERN_ERR "implementation missing\n");
 568                 return NULL;
 569         case RES_COUNTER:
 570                 ret = alloc_counter_tr(id);
 571                 break;
 572         case RES_XRCD:
 573                 ret = alloc_xrcdn_tr(id);
 574                 break;
 575         case RES_FS_RULE:
 576                 ret = alloc_fs_rule_tr(id);
 577                 break;
 578         default:
 579                 return NULL;
 580         }
 581         if (ret)
 582                 ret->owner = slave;
 583
 584         return ret;
 585 }
 586
 587 static int add_res_range(struct mlx4_dev *dev, int slave, u64 base, int count,
 588                          enum mlx4_resource type, int extra)
 589 {
 590         int i;
 591         int err;
 592         struct mlx4_priv *priv = mlx4_priv(dev);
 593         struct res_common **res_arr;
 594         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
 595         struct rb_root *root = &tracker->res_tree[type];
 596
 597         res_arr = kzalloc(count * sizeof *res_arr, GFP_KERNEL);
 598         if (!res_arr)
 599                 return -ENOMEM;
 600
 601         for (i = 0; i < count; ++i) {
 602                 res_arr[i] = alloc_tr(base + i, type, slave, extra);
 603                 if (!res_arr[i]) {
 604                         for (--i; i >= 0; --i)
 605                                 kfree(res_arr[i]);
 606
 607                         kfree(res_arr);
 608                         return -ENOMEM;
 609                 }
 610         }
 611
 612         spin_lock_irq(mlx4_tlock(dev));
 613         for (i = 0; i < count; ++i) {
 614                 if (find_res(dev, base + i, type)) {
 615                         err = -EEXIST;
 616                         goto undo;
 617                 }
 618                 err = res_tracker_insert(root, res_arr[i]);
 619                 if (err)
 620                         goto undo;
 621                 list_add_tail(&res_arr[i]->list,
 622                               &tracker->slave_list[slave].res_list[type]);
 623         }
 624         spin_unlock_irq(mlx4_tlock(dev));
 625         kfree(res_arr);
 626
 627         return 0;
 628
 629 undo:
 630         for (--i; i >= base; --i)
 631                 rb_erase(&res_arr[i]->node, root);
 632
 633         spin_unlock_irq(mlx4_tlock(dev));
 634
 635         for (i = 0; i < count; ++i)
 636                 kfree(res_arr[i]);
 637
 638         kfree(res_arr);
 639
 640         return err;
 641 }
 642
 643 static int remove_qp_ok(struct res_qp *res)
 644 {
 645         if (res->com.state == RES_QP_BUSY)
 646                 return -EBUSY;
 647         else if (res->com.state != RES_QP_RESERVED)
 648                 return -EPERM;
 649
 650         return 0;
 651 }
 652
 653 static int remove_mtt_ok(struct res_mtt *res, int order)
 654 {
 655         if (res->com.state == RES_MTT_BUSY ||
 656             atomic_read(&res->ref_count)) {
 657                 printk(KERN_DEBUG "%s-%d: state %s, ref_count %d\n",
 658                        __func__, __LINE__,
 659                        mtt_states_str(res->com.state),
 660                        atomic_read(&res->ref_count));
 661                 return -EBUSY;
 662         } else if (res->com.state != RES_MTT_ALLOCATED)
 663                 return -EPERM;
 664         else if (res->order != order)
 665                 return -EINVAL;
 666
 667         return 0;
 668 }
 669
 670 static int remove_mpt_ok(struct res_mpt *res)
 671 {
 672         if (res->com.state == RES_MPT_BUSY)
 673                 return -EBUSY;
 674         else if (res->com.state != RES_MPT_RESERVED)
 675                 return -EPERM;
 676
 677         return 0;
 678 }
 679
 680 static int remove_eq_ok(struct res_eq *res)
 681 {
 682         if (res->com.state == RES_MPT_BUSY)
 683                 return -EBUSY;
 684         else if (res->com.state != RES_MPT_RESERVED)
 685                 return -EPERM;
 686
 687         return 0;
 688 }
 689
 690 static int remove_counter_ok(struct res_counter *res)
 691 {
 692         if (res->com.state == RES_COUNTER_BUSY)
 693                 return -EBUSY;
 694         else if (res->com.state != RES_COUNTER_ALLOCATED)
 695                 return -EPERM;
 696
 697         return 0;
 698 }
 699
 700 static int remove_xrcdn_ok(struct res_xrcdn *res)
 701 {
 702         if (res->com.state == RES_XRCD_BUSY)
 703                 return -EBUSY;
 704         else if (res->com.state != RES_XRCD_ALLOCATED)
 705                 return -EPERM;
 706
 707         return 0;
 708 }
 709
 710 static int remove_fs_rule_ok(struct res_fs_rule *res)
 711 {
 712         if (res->com.state == RES_FS_RULE_BUSY)
 713                 return -EBUSY;
 714         else if (res->com.state != RES_FS_RULE_ALLOCATED)
 715                 return -EPERM;
 716
 717         return 0;
 718 }
 719
 720 static int remove_cq_ok(struct res_cq *res)
 721 {
 722         if (res->com.state == RES_CQ_BUSY)
 723                 return -EBUSY;
 724         else if (res->com.state != RES_CQ_ALLOCATED)
 725                 return -EPERM;
 726
 727         return 0;
 728 }
 729
 730 static int remove_srq_ok(struct res_srq *res)
 731 {
 732         if (res->com.state == RES_SRQ_BUSY)
 733                 return -EBUSY;
 734         else if (res->com.state != RES_SRQ_ALLOCATED)
 735                 return -EPERM;
 736
 737         return 0;
 738 }
 739
 740 static int remove_ok(struct res_common *res, enum mlx4_resource type, int extra)
 741 {
 742         switch (type) {
 743         case RES_QP:
 744                 return remove_qp_ok((struct res_qp *)res);
 745         case RES_CQ:
 746                 return remove_cq_ok((struct res_cq *)res);
 747         case RES_SRQ:
 748                 return remove_srq_ok((struct res_srq *)res);
 749         case RES_MPT:
 750                 return remove_mpt_ok((struct res_mpt *)res);
 751         case RES_MTT:
 752                 return remove_mtt_ok((struct res_mtt *)res, extra);
 753         case RES_MAC:
 754                 return -ENOSYS;
 755         case RES_EQ:
 756                 return remove_eq_ok((struct res_eq *)res);
 757         case RES_COUNTER:
 758                 return remove_counter_ok((struct res_counter *)res);
 759         case RES_XRCD:
 760                 return remove_xrcdn_ok((struct res_xrcdn *)res);
 761         case RES_FS_RULE:
 762                 return remove_fs_rule_ok((struct res_fs_rule *)res);
 763         default:
 764                 return -EINVAL;
 765         }
 766 }
 767
 768 static int rem_res_range(struct mlx4_dev *dev, int slave, u64 base, int count,
 769                          enum mlx4_resource type, int extra)
 770 {
 771         u64 i;
 772         int err;
 773         struct mlx4_priv *priv = mlx4_priv(dev);
 774         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
 775         struct res_common *r;
 776
 777         spin_lock_irq(mlx4_tlock(dev));
 778         for (i = base; i < base + count; ++i) {
 779                 r = res_tracker_lookup(&tracker->res_tree[type], i);
 780                 if (!r) {
 781                         err = -ENOENT;
 782                         goto out;
 783                 }
 784                 if (r->owner != slave) {
 785                         err = -EPERM;
 786                         goto out;
 787                 }
 788                 err = remove_ok(r, type, extra);
 789                 if (err)
 790                         goto out;
 791         }
 792
 793         for (i = base; i < base + count; ++i) {
 794                 r = res_tracker_lookup(&tracker->res_tree[type], i);
 795                 rb_erase(&r->node, &tracker->res_tree[type]);
 796                 list_del(&r->list);
 797                 kfree(r);
 798         }
 799         err = 0;
 800
 801 out:
 802         spin_unlock_irq(mlx4_tlock(dev));
 803
 804         return err;
 805 }
 806
 807 static int qp_res_start_move_to(struct mlx4_dev *dev, int slave, int qpn,
 808                                 enum res_qp_states state, struct res_qp **qp,
 809                                 int alloc)
 810 {
 811         struct mlx4_priv *priv = mlx4_priv(dev);
 812         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
 813         struct res_qp *r;
 814         int err = 0;
 815
 816         spin_lock_irq(mlx4_tlock(dev));
 817         r = res_tracker_lookup(&tracker->res_tree[RES_QP], qpn);
 818         if (!r)
 819                 err = -ENOENT;
 820         else if (r->com.owner != slave)
 821                 err = -EPERM;
 822         else {
 823                 switch (state) {
 824                 case RES_QP_BUSY:
 825                         mlx4_dbg(dev, "%s: failed RES_QP, 0x%llx\n",
 826                                  __func__, r->com.res_id);
 827                         err = -EBUSY;
 828                         break;
 829
 830                 case RES_QP_RESERVED:
 831                         if (r->com.state == RES_QP_MAPPED && !alloc)
 832                                 break;
 833
 834                         mlx4_dbg(dev, "failed RES_QP, 0x%llx\n", r->com.res_id);
 835                         err = -EINVAL;
 836                         break;
 837
 838                 case RES_QP_MAPPED:
 839                         if ((r->com.state == RES_QP_RESERVED && alloc) ||
 840                             r->com.state == RES_QP_HW)
 841                                 break;
 842                         else {
 843                                 mlx4_dbg(dev, "failed RES_QP, 0x%llx\n",
 844                                           r->com.res_id);
 845                                 err = -EINVAL;
 846                         }
 847
 848                         break;
 849
 850                 case RES_QP_HW:
 851                         if (r->com.state != RES_QP_MAPPED)
 852                                 err = -EINVAL;
 853                         break;
 854                 default:
 855                         err = -EINVAL;
 856                 }
 857
 858                 if (!err) {
 859                         r->com.from_state = r->com.state;
 860                         r->com.to_state = state;
 861                         r->com.state = RES_QP_BUSY;
 862                         if (qp)
 863                                 *qp = r;
 864                 }
 865         }
 866
 867         spin_unlock_irq(mlx4_tlock(dev));
 868
 869         return err;
 870 }
 871
 872 static int mr_res_start_move_to(struct mlx4_dev *dev, int slave, int index,
 873                                 enum res_mpt_states state, struct res_mpt **mpt)
 874 {
 875         struct mlx4_priv *priv = mlx4_priv(dev);
 876         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
 877         struct res_mpt *r;
 878         int err = 0;
 879
 880         spin_lock_irq(mlx4_tlock(dev));
 881         r = res_tracker_lookup(&tracker->res_tree[RES_MPT], index);
 882         if (!r)
 883                 err = -ENOENT;
 884         else if (r->com.owner != slave)
 885                 err = -EPERM;
 886         else {
 887                 switch (state) {
 888                 case RES_MPT_BUSY:
 889                         err = -EINVAL;
 890                         break;
 891
 892                 case RES_MPT_RESERVED:
 893                         if (r->com.state != RES_MPT_MAPPED)
 894                                 err = -EINVAL;
 895                         break;
 896
 897                 case RES_MPT_MAPPED:
 898                         if (r->com.state != RES_MPT_RESERVED &&
 899                             r->com.state != RES_MPT_HW)
 900                                 err = -EINVAL;
 901                         break;
 902
 903                 case RES_MPT_HW:
 904                         if (r->com.state != RES_MPT_MAPPED)
 905                                 err = -EINVAL;
 906                         break;
 907                 default:
 908                         err = -EINVAL;
 909                 }
 910
 911                 if (!err) {
 912                         r->com.from_state = r->com.state;
 913                         r->com.to_state = state;
 914                         r->com.state = RES_MPT_BUSY;
 915                         if (mpt)
 916                                 *mpt = r;
 917                 }
 918         }
 919
 920         spin_unlock_irq(mlx4_tlock(dev));
 921
 922         return err;
 923 }
 924
 925 static int eq_res_start_move_to(struct mlx4_dev *dev, int slave, int index,
 926                                 enum res_eq_states state, struct res_eq **eq)
 927 {
 928         struct mlx4_priv *priv = mlx4_priv(dev);
 929         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
 930         struct res_eq *r;
 931         int err = 0;
 932
 933         spin_lock_irq(mlx4_tlock(dev));
 934         r = res_tracker_lookup(&tracker->res_tree[RES_EQ], index);
 935         if (!r)
 936                 err = -ENOENT;
 937         else if (r->com.owner != slave)
 938                 err = -EPERM;
 939         else {
 940                 switch (state) {
 941                 case RES_EQ_BUSY:
 942                         err = -EINVAL;
 943                         break;
 944
 945                 case RES_EQ_RESERVED:
 946                         if (r->com.state != RES_EQ_HW)
 947                                 err = -EINVAL;
 948                         break;
 949
 950                 case RES_EQ_HW:
 951                         if (r->com.state != RES_EQ_RESERVED)
 952                                 err = -EINVAL;
 953                         break;
 954
 955                 default:
 956                         err = -EINVAL;
 957                 }
 958
 959                 if (!err) {
 960                         r->com.from_state = r->com.state;
 961                         r->com.to_state = state;
 962                         r->com.state = RES_EQ_BUSY;
 963                         if (eq)
 964                                 *eq = r;
 965                 }
 966         }
 967
 968         spin_unlock_irq(mlx4_tlock(dev));
 969
 970         return err;
 971 }
 972
 973 static int cq_res_start_move_to(struct mlx4_dev *dev, int slave, int cqn,
 974                                 enum res_cq_states state, struct res_cq **cq)
 975 {
 976         struct mlx4_priv *priv = mlx4_priv(dev);
 977         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
 978         struct res_cq *r;
 979         int err;
 980
 981         spin_lock_irq(mlx4_tlock(dev));
 982         r = res_tracker_lookup(&tracker->res_tree[RES_CQ], cqn);
 983         if (!r)
 984                 err = -ENOENT;
 985         else if (r->com.owner != slave)
 986                 err = -EPERM;
 987         else {
 988                 switch (state) {
 989                 case RES_CQ_BUSY:
 990                         err = -EBUSY;
 991                         break;
 992
 993                 case RES_CQ_ALLOCATED:
 994                         if (r->com.state != RES_CQ_HW)
 995                                 err = -EINVAL;
 996                         else if (atomic_read(&r->ref_count))
 997                                 err = -EBUSY;
 998                         else
 999                                 err = 0;
1000                         break;
1001
1002                 case RES_CQ_HW:
1003                         if (r->com.state != RES_CQ_ALLOCATED)
1004                                 err = -EINVAL;
1005                         else
1006                                 err = 0;
1007                         break;
1008
1009                 default:
1010                         err = -EINVAL;
1011                 }
1012
1013                 if (!err) {
1014                         r->com.from_state = r->com.state;
1015                         r->com.to_state = state;
1016                         r->com.state = RES_CQ_BUSY;
1017                         if (cq)
1018                                 *cq = r;
1019                 }
1020         }
1021
1022         spin_unlock_irq(mlx4_tlock(dev));
1023
1024         return err;
1025 }
1026
1027 static int srq_res_start_move_to(struct mlx4_dev *dev, int slave, int index,
1028                                  enum res_cq_states state, struct res_srq **srq)
1029 {
1030         struct mlx4_priv *priv = mlx4_priv(dev);
1031         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1032         struct res_srq *r;
1033         int err = 0;
1034
1035         spin_lock_irq(mlx4_tlock(dev));
1036         r = res_tracker_lookup(&tracker->res_tree[RES_SRQ], index);
1037         if (!r)
1038                 err = -ENOENT;
1039         else if (r->com.owner != slave)
1040                 err = -EPERM;
1041         else {
1042                 switch (state) {
1043                 case RES_SRQ_BUSY:
1044                         err = -EINVAL;
1045                         break;
1046
1047                 case RES_SRQ_ALLOCATED:
1048                         if (r->com.state != RES_SRQ_HW)
1049                                 err = -EINVAL;
1050                         else if (atomic_read(&r->ref_count))
1051                                 err = -EBUSY;
1052                         break;
1053
1054                 case RES_SRQ_HW:
1055                         if (r->com.state != RES_SRQ_ALLOCATED)
1056                                 err = -EINVAL;
1057                         break;
1058
1059                 default:
1060                         err = -EINVAL;
1061                 }
1062
1063                 if (!err) {
1064                         r->com.from_state = r->com.state;
1065                         r->com.to_state = state;
1066                         r->com.state = RES_SRQ_BUSY;
1067                         if (srq)
1068                                 *srq = r;
1069                 }
1070         }
1071
1072         spin_unlock_irq(mlx4_tlock(dev));
1073
1074         return err;
1075 }
1076
1077 static void res_abort_move(struct mlx4_dev *dev, int slave,
1078                            enum mlx4_resource type, int id)
1079 {
1080         struct mlx4_priv *priv = mlx4_priv(dev);
1081         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1082         struct res_common *r;
1083
1084         spin_lock_irq(mlx4_tlock(dev));
1085         r = res_tracker_lookup(&tracker->res_tree[type], id);
1086         if (r && (r->owner == slave))
1087                 r->state = r->from_state;
1088         spin_unlock_irq(mlx4_tlock(dev));
1089 }
1090
1091 static void res_end_move(struct mlx4_dev *dev, int slave,
1092                          enum mlx4_resource type, int id)
1093 {
1094         struct mlx4_priv *priv = mlx4_priv(dev);
1095         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1096         struct res_common *r;
1097
1098         spin_lock_irq(mlx4_tlock(dev));
1099         r = res_tracker_lookup(&tracker->res_tree[type], id);
1100         if (r && (r->owner == slave))
1101                 r->state = r->to_state;
1102         spin_unlock_irq(mlx4_tlock(dev));
1103 }
1104
1105 static int valid_reserved(struct mlx4_dev *dev, int slave, int qpn)
1106 {
1107         return mlx4_is_qp_reserved(dev, qpn);
1108 }
1109
1110 static int qp_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1111                         u64 in_param, u64 *out_param)
1112 {
1113         int err;
1114         int count;
1115         int align;
1116         int base;
1117         int qpn;
1118
1119         switch (op) {
1120         case RES_OP_RESERVE:
1121                 count = get_param_l(&in_param);
1122                 align = get_param_h(&in_param);
1123                 err = __mlx4_qp_reserve_range(dev, count, align, &base);
1124                 if (err)
1125                         return err;
1126
1127                 err = add_res_range(dev, slave, base, count, RES_QP, 0);
1128                 if (err) {
1129                         __mlx4_qp_release_range(dev, base, count);
1130                         return err;
1131                 }
1132                 set_param_l(out_param, base);
1133                 break;
1134         case RES_OP_MAP_ICM:
1135                 qpn = get_param_l(&in_param) & 0x7fffff;
1136                 if (valid_reserved(dev, slave, qpn)) {
1137                         err = add_res_range(dev, slave, qpn, 1, RES_QP, 0);
1138                         if (err)
1139                                 return err;
1140                 }
1141
1142                 err = qp_res_start_move_to(dev, slave, qpn, RES_QP_MAPPED,
1143                                            NULL, 1);
1144                 if (err)
1145                         return err;
1146
1147                 if (!valid_reserved(dev, slave, qpn)) {
1148                         err = __mlx4_qp_alloc_icm(dev, qpn);
1149                         if (err) {
1150                                 res_abort_move(dev, slave, RES_QP, qpn);
1151                                 return err;
1152                         }
1153                 }
1154
1155                 res_end_move(dev, slave, RES_QP, qpn);
1156                 break;
1157
1158         default:
1159                 err = -EINVAL;
1160                 break;
1161         }
1162         return err;
1163 }
1164
1165 static int mtt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1166                          u64 in_param, u64 *out_param)
1167 {
1168         int err = -EINVAL;
1169         int base;
1170         int order;
1171
1172         if (op != RES_OP_RESERVE_AND_MAP)
1173                 return err;
1174
1175         order = get_param_l(&in_param);
1176         base = __mlx4_alloc_mtt_range(dev, order);
1177         if (base == -1)
1178                 return -ENOMEM;
1179
1180         err = add_res_range(dev, slave, base, 1, RES_MTT, order);
1181         if (err)
1182                 __mlx4_free_mtt_range(dev, base, order);
1183         else
1184                 set_param_l(out_param, base);
1185
1186         return err;
1187 }
1188
1189 static int mpt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1190                          u64 in_param, u64 *out_param)
1191 {
1192         int err = -EINVAL;
1193         int index;
1194         int id;
1195         struct res_mpt *mpt;
1196
1197         switch (op) {
1198         case RES_OP_RESERVE:
1199                 index = __mlx4_mr_reserve(dev);
1200                 if (index == -1)
1201                         break;
1202                 id = index & mpt_mask(dev);
1203
1204                 err = add_res_range(dev, slave, id, 1, RES_MPT, index);
1205                 if (err) {
1206                         __mlx4_mr_release(dev, index);
1207                         break;
1208                 }
1209                 set_param_l(out_param, index);
1210                 break;
1211         case RES_OP_MAP_ICM:
1212                 index = get_param_l(&in_param);
1213                 id = index & mpt_mask(dev);
1214                 err = mr_res_start_move_to(dev, slave, id,
1215                                            RES_MPT_MAPPED, &mpt);
1216                 if (err)
1217                         return err;
1218
1219                 err = __mlx4_mr_alloc_icm(dev, mpt->key);
1220                 if (err) {
1221                         res_abort_move(dev, slave, RES_MPT, id);
1222                         return err;
1223                 }
1224
1225                 res_end_move(dev, slave, RES_MPT, id);
1226                 break;
1227         }
1228         return err;
1229 }
1230
1231 static int cq_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1232                         u64 in_param, u64 *out_param)
1233 {
1234         int cqn;
1235         int err;
1236
1237         switch (op) {
1238         case RES_OP_RESERVE_AND_MAP:
1239                 err = __mlx4_cq_alloc_icm(dev, &cqn);
1240                 if (err)
1241                         break;
1242
1243                 err = add_res_range(dev, slave, cqn, 1, RES_CQ, 0);
1244                 if (err) {
1245                         __mlx4_cq_free_icm(dev, cqn);
1246                         break;
1247                 }
1248
1249                 set_param_l(out_param, cqn);
1250                 break;
1251
1252         default:
1253                 err = -EINVAL;
1254         }
1255
1256         return err;
1257 }
1258
1259 static int srq_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1260                          u64 in_param, u64 *out_param)
1261 {
1262         int srqn;
1263         int err;
1264
1265         switch (op) {
1266         case RES_OP_RESERVE_AND_MAP:
1267                 err = __mlx4_srq_alloc_icm(dev, &srqn);
1268                 if (err)
1269                         break;
1270
1271                 err = add_res_range(dev, slave, srqn, 1, RES_SRQ, 0);
1272                 if (err) {
1273                         __mlx4_srq_free_icm(dev, srqn);
1274                         break;
1275                 }
1276
1277                 set_param_l(out_param, srqn);
1278                 break;
1279
1280         default:
1281                 err = -EINVAL;
1282         }
1283
1284         return err;
1285 }
1286
1287 static int mac_add_to_slave(struct mlx4_dev *dev, int slave, u64 mac, int port)
1288 {
1289         struct mlx4_priv *priv = mlx4_priv(dev);
1290         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1291         struct mac_res *res;
1292
1293         res = kzalloc(sizeof *res, GFP_KERNEL);
1294         if (!res)
1295                 return -ENOMEM;
1296         res->mac = mac;
1297         res->port = (u8) port;
1298         list_add_tail(&res->list,
1299                       &tracker->slave_list[slave].res_list[RES_MAC]);
1300         return 0;
1301 }
1302
1303 static void mac_del_from_slave(struct mlx4_dev *dev, int slave, u64 mac,
1304                                int port)
1305 {
1306         struct mlx4_priv *priv = mlx4_priv(dev);
1307         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1308         struct list_head *mac_list =
1309                 &tracker->slave_list[slave].res_list[RES_MAC];
1310         struct mac_res *res, *tmp;
1311
1312         list_for_each_entry_safe(res, tmp, mac_list, list) {
1313                 if (res->mac == mac && res->port == (u8) port) {
1314                         list_del(&res->list);
1315                         kfree(res);
1316                         break;
1317                 }
1318         }
1319 }
1320
1321 static void rem_slave_macs(struct mlx4_dev *dev, int slave)
1322 {
1323         struct mlx4_priv *priv = mlx4_priv(dev);
1324         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1325         struct list_head *mac_list =
1326                 &tracker->slave_list[slave].res_list[RES_MAC];
1327         struct mac_res *res, *tmp;
1328
1329         list_for_each_entry_safe(res, tmp, mac_list, list) {
1330                 list_del(&res->list);
1331                 __mlx4_unregister_mac(dev, res->port, res->mac);
1332                 kfree(res);
1333         }
1334 }
1335
1336 static int mac_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1337                          u64 in_param, u64 *out_param)
1338 {
1339         int err = -EINVAL;
1340         int port;
1341         u64 mac;
1342
1343         if (op != RES_OP_RESERVE_AND_MAP)
1344                 return err;
1345
1346         port = get_param_l(out_param);
1347         mac = in_param;
1348
1349         err = __mlx4_register_mac(dev, port, mac);
1350         if (err >= 0) {
1351                 set_param_l(out_param, err);
1352                 err = 0;
1353         }
1354
1355         if (!err) {
1356                 err = mac_add_to_slave(dev, slave, mac, port);
1357                 if (err)
1358                         __mlx4_unregister_mac(dev, port, mac);
1359         }
1360         return err;
1361 }
1362
1363 static int vlan_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1364                          u64 in_param, u64 *out_param)
1365 {
1366         return 0;
1367 }
1368
1369 static int counter_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1370                              u64 in_param, u64 *out_param)
1371 {
1372         u32 index;
1373         int err;
1374
1375         if (op != RES_OP_RESERVE)
1376                 return -EINVAL;
1377
1378         err = __mlx4_counter_alloc(dev, &index);
1379         if (err)
1380                 return err;
1381
1382         err = add_res_range(dev, slave, index, 1, RES_COUNTER, 0);
1383         if (err)
1384                 __mlx4_counter_free(dev, index);
1385         else
1386                 set_param_l(out_param, index);
1387
1388         return err;
1389 }
1390
1391 static int xrcdn_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1392                            u64 in_param, u64 *out_param)
1393 {
1394         u32 xrcdn;
1395         int err;
1396
1397         if (op != RES_OP_RESERVE)
1398                 return -EINVAL;
1399
1400         err = __mlx4_xrcd_alloc(dev, &xrcdn);
1401         if (err)
1402                 return err;
1403
1404         err = add_res_range(dev, slave, xrcdn, 1, RES_XRCD, 0);
1405         if (err)
1406                 __mlx4_xrcd_free(dev, xrcdn);
1407         else
1408                 set_param_l(out_param, xrcdn);
1409
1410         return err;
1411 }
1412
1413 int mlx4_ALLOC_RES_wrapper(struct mlx4_dev *dev, int slave,
1414                            struct mlx4_vhcr *vhcr,
1415                            struct mlx4_cmd_mailbox *inbox,
1416                            struct mlx4_cmd_mailbox *outbox,
1417                            struct mlx4_cmd_info *cmd)
1418 {
1419         int err;
1420         int alop = vhcr->op_modifier;
1421
1422         switch (vhcr->in_modifier) {
1423         case RES_QP:
1424                 err = qp_alloc_res(dev, slave, vhcr->op_modifier, alop,
1425                                    vhcr->in_param, &vhcr->out_param);
1426                 break;
1427
1428         case RES_MTT:
1429                 err = mtt_alloc_res(dev, slave, vhcr->op_modifier, alop,
1430                                     vhcr->in_param, &vhcr->out_param);
1431                 break;
1432
1433         case RES_MPT:
1434                 err = mpt_alloc_res(dev, slave, vhcr->op_modifier, alop,
1435                                     vhcr->in_param, &vhcr->out_param);
1436                 break;
1437
1438         case RES_CQ:
1439                 err = cq_alloc_res(dev, slave, vhcr->op_modifier, alop,
1440                                    vhcr->in_param, &vhcr->out_param);
1441                 break;
1442
1443         case RES_SRQ:
1444                 err = srq_alloc_res(dev, slave, vhcr->op_modifier, alop,
1445                                     vhcr->in_param, &vhcr->out_param);
1446                 break;
1447
1448         case RES_MAC:
1449                 err = mac_alloc_res(dev, slave, vhcr->op_modifier, alop,
1450                                     vhcr->in_param, &vhcr->out_param);
1451                 break;
1452
1453         case RES_VLAN:
1454                 err = vlan_alloc_res(dev, slave, vhcr->op_modifier, alop,
1455                                     vhcr->in_param, &vhcr->out_param);
1456                 break;
1457
1458         case RES_COUNTER:
1459                 err = counter_alloc_res(dev, slave, vhcr->op_modifier, alop,
1460                                         vhcr->in_param, &vhcr->out_param);
1461                 break;
1462
1463         case RES_XRCD:
1464                 err = xrcdn_alloc_res(dev, slave, vhcr->op_modifier, alop,
1465                                       vhcr->in_param, &vhcr->out_param);
1466                 break;
1467
1468         default:
1469                 err = -EINVAL;
1470                 break;
1471         }
1472
1473         return err;
1474 }
1475
1476 static int qp_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1477                        u64 in_param)
1478 {
1479         int err;
1480         int count;
1481         int base;
1482         int qpn;
1483
1484         switch (op) {
1485         case RES_OP_RESERVE:
1486                 base = get_param_l(&in_param) & 0x7fffff;
1487                 count = get_param_h(&in_param);
1488                 err = rem_res_range(dev, slave, base, count, RES_QP, 0);
1489                 if (err)
1490                         break;
1491                 __mlx4_qp_release_range(dev, base, count);
1492                 break;
1493         case RES_OP_MAP_ICM:
1494                 qpn = get_param_l(&in_param) & 0x7fffff;
1495                 err = qp_res_start_move_to(dev, slave, qpn, RES_QP_RESERVED,
1496                                            NULL, 0);
1497                 if (err)
1498                         return err;
1499
1500                 if (!valid_reserved(dev, slave, qpn))
1501                         __mlx4_qp_free_icm(dev, qpn);
1502
1503                 res_end_move(dev, slave, RES_QP, qpn);
1504
1505                 if (valid_reserved(dev, slave, qpn))
1506                         err = rem_res_range(dev, slave, qpn, 1, RES_QP, 0);
1507                 break;
1508         default:
1509                 err = -EINVAL;
1510                 break;
1511         }
1512         return err;
1513 }
1514
1515 static int mtt_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1516                         u64 in_param, u64 *out_param)
1517 {
1518         int err = -EINVAL;
1519         int base;
1520         int order;
1521
1522         if (op != RES_OP_RESERVE_AND_MAP)
1523                 return err;
1524
1525         base = get_param_l(&in_param);
1526         order = get_param_h(&in_param);
1527         err = rem_res_range(dev, slave, base, 1, RES_MTT, order);
1528         if (!err)
1529                 __mlx4_free_mtt_range(dev, base, order);
1530         return err;
1531 }
1532
1533 static int mpt_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1534                         u64 in_param)
1535 {
1536         int err = -EINVAL;
1537         int index;
1538         int id;
1539         struct res_mpt *mpt;
1540
1541         switch (op) {
1542         case RES_OP_RESERVE:
1543                 index = get_param_l(&in_param);
1544                 id = index & mpt_mask(dev);
1545                 err = get_res(dev, slave, id, RES_MPT, &mpt);
1546                 if (err)
1547                         break;
1548                 index = mpt->key;
1549                 put_res(dev, slave, id, RES_MPT);
1550
1551                 err = rem_res_range(dev, slave, id, 1, RES_MPT, 0);
1552                 if (err)
1553                         break;
1554                 __mlx4_mr_release(dev, index);
1555                 break;
1556         case RES_OP_MAP_ICM:
1557                         index = get_param_l(&in_param);
1558                         id = index & mpt_mask(dev);
1559                         err = mr_res_start_move_to(dev, slave, id,
1560                                                    RES_MPT_RESERVED, &mpt);
1561                         if (err)
1562                                 return err;
1563
1564                         __mlx4_mr_free_icm(dev, mpt->key);
1565                         res_end_move(dev, slave, RES_MPT, id);
1566                         return err;
1567                 break;
1568         default:
1569                 err = -EINVAL;
1570                 break;
1571         }
1572         return err;
1573 }
1574
1575 static int cq_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1576                        u64 in_param, u64 *out_param)
1577 {
1578         int cqn;
1579         int err;
1580
1581         switch (op) {
1582         case RES_OP_RESERVE_AND_MAP:
1583                 cqn = get_param_l(&in_param);
1584                 err = rem_res_range(dev, slave, cqn, 1, RES_CQ, 0);
1585                 if (err)
1586                         break;
1587
1588                 __mlx4_cq_free_icm(dev, cqn);
1589                 break;
1590
1591         default:
1592                 err = -EINVAL;
1593                 break;
1594         }
1595
1596         return err;
1597 }
1598
1599 static int srq_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1600                         u64 in_param, u64 *out_param)
1601 {
1602         int srqn;
1603         int err;
1604
1605         switch (op) {
1606         case RES_OP_RESERVE_AND_MAP:
1607                 srqn = get_param_l(&in_param);
1608                 err = rem_res_range(dev, slave, srqn, 1, RES_SRQ, 0);
1609                 if (err)
1610                         break;
1611
1612                 __mlx4_srq_free_icm(dev, srqn);
1613                 break;
1614
1615         default:
1616                 err = -EINVAL;
1617                 break;
1618         }
1619
1620         return err;
1621 }
1622
1623 static int mac_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1624                             u64 in_param, u64 *out_param)
1625 {
1626         int port;
1627         int err = 0;
1628
1629         switch (op) {
1630         case RES_OP_RESERVE_AND_MAP:
1631                 port = get_param_l(out_param);
1632                 mac_del_from_slave(dev, slave, in_param, port);
1633                 __mlx4_unregister_mac(dev, port, in_param);
1634                 break;
1635         default:
1636                 err = -EINVAL;
1637                 break;
1638         }
1639
1640         return err;
1641
1642 }
1643
1644 static int vlan_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1645                             u64 in_param, u64 *out_param)
1646 {
1647         return 0;
1648 }
1649
1650 static int counter_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1651                             u64 in_param, u64 *out_param)
1652 {
1653         int index;
1654         int err;
1655
1656         if (op != RES_OP_RESERVE)
1657                 return -EINVAL;
1658
1659         index = get_param_l(&in_param);
1660         err = rem_res_range(dev, slave, index, 1, RES_COUNTER, 0);
1661         if (err)
1662                 return err;
1663
1664         __mlx4_counter_free(dev, index);
1665
1666         return err;
1667 }
1668
1669 static int xrcdn_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1670                           u64 in_param, u64 *out_param)
1671 {
1672         int xrcdn;
1673         int err;
1674
1675         if (op != RES_OP_RESERVE)
1676                 return -EINVAL;
1677
1678         xrcdn = get_param_l(&in_param);
1679         err = rem_res_range(dev, slave, xrcdn, 1, RES_XRCD, 0);
1680         if (err)
1681                 return err;
1682
1683         __mlx4_xrcd_free(dev, xrcdn);
1684
1685         return err;
1686 }
1687
1688 int mlx4_FREE_RES_wrapper(struct mlx4_dev *dev, int slave,
1689                           struct mlx4_vhcr *vhcr,
1690                           struct mlx4_cmd_mailbox *inbox,
1691                           struct mlx4_cmd_mailbox *outbox,
1692                           struct mlx4_cmd_info *cmd)
1693 {
1694         int err = -EINVAL;
1695         int alop = vhcr->op_modifier;
1696
1697         switch (vhcr->in_modifier) {
1698         case RES_QP:
1699                 err = qp_free_res(dev, slave, vhcr->op_modifier, alop,
1700                                   vhcr->in_param);
1701                 break;
1702
1703         case RES_MTT:
1704                 err = mtt_free_res(dev, slave, vhcr->op_modifier, alop,
1705                                    vhcr->in_param, &vhcr->out_param);
1706                 break;
1707
1708         case RES_MPT:
1709                 err = mpt_free_res(dev, slave, vhcr->op_modifier, alop,
1710                                    vhcr->in_param);
1711                 break;
1712
1713         case RES_CQ:
1714                 err = cq_free_res(dev, slave, vhcr->op_modifier, alop,
1715                                   vhcr->in_param, &vhcr->out_param);
1716                 break;
1717
1718         case RES_SRQ:
1719                 err = srq_free_res(dev, slave, vhcr->op_modifier, alop,
1720                                    vhcr->in_param, &vhcr->out_param);
1721                 break;
1722
1723         case RES_MAC:
1724                 err = mac_free_res(dev, slave, vhcr->op_modifier, alop,
1725                                    vhcr->in_param, &vhcr->out_param);
1726                 break;
1727
1728         case RES_VLAN:
1729                 err = vlan_free_res(dev, slave, vhcr->op_modifier, alop,
1730                                    vhcr->in_param, &vhcr->out_param);
1731                 break;
1732
1733         case RES_COUNTER:
1734                 err = counter_free_res(dev, slave, vhcr->op_modifier, alop,
1735                                        vhcr->in_param, &vhcr->out_param);
1736                 break;
1737
1738         case RES_XRCD:
1739                 err = xrcdn_free_res(dev, slave, vhcr->op_modifier, alop,
1740                                      vhcr->in_param, &vhcr->out_param);
1741
1742         default:
1743                 break;
1744         }
1745         return err;
1746 }
1747
1748 /* ugly but other choices are uglier */
1749 static int mr_phys_mpt(struct mlx4_mpt_entry *mpt)
1750 {
1751         return (be32_to_cpu(mpt->flags) >> 9) & 1;
1752 }
1753
1754 static int mr_get_mtt_addr(struct mlx4_mpt_entry *mpt)
1755 {
1756         return (int)be64_to_cpu(mpt->mtt_addr) & 0xfffffff8;
1757 }
1758
1759 static int mr_get_mtt_size(struct mlx4_mpt_entry *mpt)
1760 {
1761         return be32_to_cpu(mpt->mtt_sz);
1762 }
1763
1764 static int qp_get_mtt_addr(struct mlx4_qp_context *qpc)
1765 {
1766         return be32_to_cpu(qpc->mtt_base_addr_l) & 0xfffffff8;
1767 }
1768
1769 static int srq_get_mtt_addr(struct mlx4_srq_context *srqc)
1770 {
1771         return be32_to_cpu(srqc->mtt_base_addr_l) & 0xfffffff8;
1772 }
1773
1774 static int qp_get_mtt_size(struct mlx4_qp_context *qpc)
1775 {
1776         int page_shift = (qpc->log_page_size & 0x3f) + 12;
1777         int log_sq_size = (qpc->sq_size_stride >> 3) & 0xf;
1778         int log_sq_sride = qpc->sq_size_stride & 7;
1779         int log_rq_size = (qpc->rq_size_stride >> 3) & 0xf;
1780         int log_rq_stride = qpc->rq_size_stride & 7;
1781         int srq = (be32_to_cpu(qpc->srqn) >> 24) & 1;
1782         int rss = (be32_to_cpu(qpc->flags) >> 13) & 1;
1783         int xrc = (be32_to_cpu(qpc->local_qpn) >> 23) & 1;
1784         int sq_size;
1785         int rq_size;
1786         int total_pages;
1787         int total_mem;
1788         int page_offset = (be32_to_cpu(qpc->params2) >> 6) & 0x3f;
1789
1790         sq_size = 1 << (log_sq_size + log_sq_sride + 4);
1791         rq_size = (srq|rss|xrc) ? 0 : (1 << (log_rq_size + log_rq_stride + 4));
1792         total_mem = sq_size + rq_size;
1793         total_pages =
1794                 roundup_pow_of_two((total_mem + (page_offset << 6)) >>
1795                                    page_shift);
1796
1797         return total_pages;
1798 }
1799
1800 static int check_mtt_range(struct mlx4_dev *dev, int slave, int start,
1801                            int size, struct res_mtt *mtt)
1802 {
1803         int res_start = mtt->com.res_id;
1804         int res_size = (1 << mtt->order);
1805
1806         if (start < res_start || start + size > res_start + res_size)
1807                 return -EPERM;
1808         return 0;
1809 }
1810
1811 int mlx4_SW2HW_MPT_wrapper(struct mlx4_dev *dev, int slave,
1812                            struct mlx4_vhcr *vhcr,
1813                            struct mlx4_cmd_mailbox *inbox,
1814                            struct mlx4_cmd_mailbox *outbox,
1815                            struct mlx4_cmd_info *cmd)
1816 {
1817         int err;
1818         int index = vhcr->in_modifier;
1819         struct res_mtt *mtt;
1820         struct res_mpt *mpt;
1821         int mtt_base = mr_get_mtt_addr(inbox->buf) / dev->caps.mtt_entry_sz;
1822         int phys;
1823         int id;
1824
1825         id = index & mpt_mask(dev);
1826         err = mr_res_start_move_to(dev, slave, id, RES_MPT_HW, &mpt);
1827         if (err)
1828                 return err;
1829
1830         phys = mr_phys_mpt(inbox->buf);
1831         if (!phys) {
1832                 err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
1833                 if (err)
1834                         goto ex_abort;
1835
1836                 err = check_mtt_range(dev, slave, mtt_base,
1837                                       mr_get_mtt_size(inbox->buf), mtt);
1838                 if (err)
1839                         goto ex_put;
1840
1841                 mpt->mtt = mtt;
1842         }
1843
1844         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1845         if (err)
1846                 goto ex_put;
1847
1848         if (!phys) {
1849                 atomic_inc(&mtt->ref_count);
1850                 put_res(dev, slave, mtt->com.res_id, RES_MTT);
1851         }
1852
1853         res_end_move(dev, slave, RES_MPT, id);
1854         return 0;
1855
1856 ex_put:
1857         if (!phys)
1858                 put_res(dev, slave, mtt->com.res_id, RES_MTT);
1859 ex_abort:
1860         res_abort_move(dev, slave, RES_MPT, id);
1861
1862         return err;
1863 }
1864
1865 int mlx4_HW2SW_MPT_wrapper(struct mlx4_dev *dev, int slave,
1866                            struct mlx4_vhcr *vhcr,
1867                            struct mlx4_cmd_mailbox *inbox,
1868                            struct mlx4_cmd_mailbox *outbox,
1869                            struct mlx4_cmd_info *cmd)
1870 {
1871         int err;
1872         int index = vhcr->in_modifier;
1873         struct res_mpt *mpt;
1874         int id;
1875
1876         id = index & mpt_mask(dev);
1877         err = mr_res_start_move_to(dev, slave, id, RES_MPT_MAPPED, &mpt);
1878         if (err)
1879                 return err;
1880
1881         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1882         if (err)
1883                 goto ex_abort;
1884
1885         if (mpt->mtt)
1886                 atomic_dec(&mpt->mtt->ref_count);
1887
1888         res_end_move(dev, slave, RES_MPT, id);
1889         return 0;
1890
1891 ex_abort:
1892         res_abort_move(dev, slave, RES_MPT, id);
1893
1894         return err;
1895 }
1896
1897 int mlx4_QUERY_MPT_wrapper(struct mlx4_dev *dev, int slave,
1898                            struct mlx4_vhcr *vhcr,
1899                            struct mlx4_cmd_mailbox *inbox,
1900                            struct mlx4_cmd_mailbox *outbox,
1901                            struct mlx4_cmd_info *cmd)
1902 {
1903         int err;
1904         int index = vhcr->in_modifier;
1905         struct res_mpt *mpt;
1906         int id;
1907
1908         id = index & mpt_mask(dev);
1909         err = get_res(dev, slave, id, RES_MPT, &mpt);
1910         if (err)
1911                 return err;
1912
1913         if (mpt->com.from_state != RES_MPT_HW) {
1914                 err = -EBUSY;
1915                 goto out;
1916         }
1917
1918         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1919
1920 out:
1921         put_res(dev, slave, id, RES_MPT);
1922         return err;
1923 }
1924
1925 static int qp_get_rcqn(struct mlx4_qp_context *qpc)
1926 {
1927         return be32_to_cpu(qpc->cqn_recv) & 0xffffff;
1928 }
1929
1930 static int qp_get_scqn(struct mlx4_qp_context *qpc)
1931 {
1932         return be32_to_cpu(qpc->cqn_send) & 0xffffff;
1933 }
1934
1935 static u32 qp_get_srqn(struct mlx4_qp_context *qpc)
1936 {
1937         return be32_to_cpu(qpc->srqn) & 0x1ffffff;
1938 }
1939
1940 int mlx4_RST2INIT_QP_wrapper(struct mlx4_dev *dev, int slave,
1941                              struct mlx4_vhcr *vhcr,
1942                              struct mlx4_cmd_mailbox *inbox,
1943                              struct mlx4_cmd_mailbox *outbox,
1944                              struct mlx4_cmd_info *cmd)
1945 {
1946         int err;
1947         int qpn = vhcr->in_modifier & 0x7fffff;
1948         struct res_mtt *mtt;
1949         struct res_qp *qp;
1950         struct mlx4_qp_context *qpc = inbox->buf + 8;
1951         int mtt_base = qp_get_mtt_addr(qpc) / dev->caps.mtt_entry_sz;
1952         int mtt_size = qp_get_mtt_size(qpc);
1953         struct res_cq *rcq;
1954         struct res_cq *scq;
1955         int rcqn = qp_get_rcqn(qpc);
1956         int scqn = qp_get_scqn(qpc);
1957         u32 srqn = qp_get_srqn(qpc) & 0xffffff;
1958         int use_srq = (qp_get_srqn(qpc) >> 24) & 1;
1959         struct res_srq *srq;
1960         int local_qpn = be32_to_cpu(qpc->local_qpn) & 0xffffff;
1961
1962         err = qp_res_start_move_to(dev, slave, qpn, RES_QP_HW, &qp, 0);
1963         if (err)
1964                 return err;
1965         qp->local_qpn = local_qpn;
1966
1967         err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
1968         if (err)
1969                 goto ex_abort;
1970
1971         err = check_mtt_range(dev, slave, mtt_base, mtt_size, mtt);
1972         if (err)
1973                 goto ex_put_mtt;
1974
1975         err = get_res(dev, slave, rcqn, RES_CQ, &rcq);
1976         if (err)
1977                 goto ex_put_mtt;
1978
1979         if (scqn != rcqn) {
1980                 err = get_res(dev, slave, scqn, RES_CQ, &scq);
1981                 if (err)
1982                         goto ex_put_rcq;
1983         } else
1984                 scq = rcq;
1985
1986         if (use_srq) {
1987                 err = get_res(dev, slave, srqn, RES_SRQ, &srq);
1988                 if (err)
1989                         goto ex_put_scq;
1990         }
1991
1992         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1993         if (err)
1994                 goto ex_put_srq;
1995         atomic_inc(&mtt->ref_count);
1996         qp->mtt = mtt;
1997         atomic_inc(&rcq->ref_count);
1998         qp->rcq = rcq;
1999         atomic_inc(&scq->ref_count);
2000         qp->scq = scq;
2001
2002         if (scqn != rcqn)
2003                 put_res(dev, slave, scqn, RES_CQ);
2004
2005         if (use_srq) {
2006                 atomic_inc(&srq->ref_count);
2007                 put_res(dev, slave, srqn, RES_SRQ);
2008                 qp->srq = srq;
2009         }
2010         put_res(dev, slave, rcqn, RES_CQ);
2011         put_res(dev, slave, mtt_base, RES_MTT);
2012         res_end_move(dev, slave, RES_QP, qpn);
2013
2014         return 0;
2015
2016 ex_put_srq:
2017         if (use_srq)
2018                 put_res(dev, slave, srqn, RES_SRQ);
2019 ex_put_scq:
2020         if (scqn != rcqn)
2021                 put_res(dev, slave, scqn, RES_CQ);
2022 ex_put_rcq:
2023         put_res(dev, slave, rcqn, RES_CQ);
2024 ex_put_mtt:
2025         put_res(dev, slave, mtt_base, RES_MTT);
2026 ex_abort:
2027         res_abort_move(dev, slave, RES_QP, qpn);
2028
2029         return err;
2030 }
2031
2032 static int eq_get_mtt_addr(struct mlx4_eq_context *eqc)
2033 {
2034         return be32_to_cpu(eqc->mtt_base_addr_l) & 0xfffffff8;
2035 }
2036
2037 static int eq_get_mtt_size(struct mlx4_eq_context *eqc)
2038 {
2039         int log_eq_size = eqc->log_eq_size & 0x1f;
2040         int page_shift = (eqc->log_page_size & 0x3f) + 12;
2041
2042         if (log_eq_size + 5 < page_shift)
2043                 return 1;
2044
2045         return 1 << (log_eq_size + 5 - page_shift);
2046 }
2047
2048 static int cq_get_mtt_addr(struct mlx4_cq_context *cqc)
2049 {
2050         return be32_to_cpu(cqc->mtt_base_addr_l) & 0xfffffff8;
2051 }
2052
2053 static int cq_get_mtt_size(struct mlx4_cq_context *cqc)
2054 {
2055         int log_cq_size = (be32_to_cpu(cqc->logsize_usrpage) >> 24) & 0x1f;
2056         int page_shift = (cqc->log_page_size & 0x3f) + 12;
2057
2058         if (log_cq_size + 5 < page_shift)
2059                 return 1;
2060
2061         return 1 << (log_cq_size + 5 - page_shift);
2062 }
2063
2064 int mlx4_SW2HW_EQ_wrapper(struct mlx4_dev *dev, int slave,
2065                           struct mlx4_vhcr *vhcr,
2066                           struct mlx4_cmd_mailbox *inbox,
2067                           struct mlx4_cmd_mailbox *outbox,
2068                           struct mlx4_cmd_info *cmd)
2069 {
2070         int err;
2071         int eqn = vhcr->in_modifier;
2072         int res_id = (slave << 8) | eqn;
2073         struct mlx4_eq_context *eqc = inbox->buf;
2074         int mtt_base = eq_get_mtt_addr(eqc) / dev->caps.mtt_entry_sz;
2075         int mtt_size = eq_get_mtt_size(eqc);
2076         struct res_eq *eq;
2077         struct res_mtt *mtt;
2078
2079         err = add_res_range(dev, slave, res_id, 1, RES_EQ, 0);
2080         if (err)
2081                 return err;
2082         err = eq_res_start_move_to(dev, slave, res_id, RES_EQ_HW, &eq);
2083         if (err)
2084                 goto out_add;
2085
2086         err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
2087         if (err)
2088                 goto out_move;
2089
2090         err = check_mtt_range(dev, slave, mtt_base, mtt_size, mtt);
2091         if (err)
2092                 goto out_put;
2093
2094         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2095         if (err)
2096                 goto out_put;
2097
2098         atomic_inc(&mtt->ref_count);
2099         eq->mtt = mtt;
2100         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2101         res_end_move(dev, slave, RES_EQ, res_id);
2102         return 0;
2103
2104 out_put:
2105         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2106 out_move:
2107         res_abort_move(dev, slave, RES_EQ, res_id);
2108 out_add:
2109         rem_res_range(dev, slave, res_id, 1, RES_EQ, 0);
2110         return err;
2111 }
2112
2113 static int get_containing_mtt(struct mlx4_dev *dev, int slave, int start,
2114                               int len, struct res_mtt **res)
2115 {
2116         struct mlx4_priv *priv = mlx4_priv(dev);
2117         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
2118         struct res_mtt *mtt;
2119         int err = -EINVAL;
2120
2121         spin_lock_irq(mlx4_tlock(dev));
2122         list_for_each_entry(mtt, &tracker->slave_list[slave].res_list[RES_MTT],
2123                             com.list) {
2124                 if (!check_mtt_range(dev, slave, start, len, mtt)) {
2125                         *res = mtt;
2126                         mtt->com.from_state = mtt->com.state;
2127                         mtt->com.state = RES_MTT_BUSY;
2128                         err = 0;
2129                         break;
2130                 }
2131         }
2132         spin_unlock_irq(mlx4_tlock(dev));
2133
2134         return err;
2135 }
2136
2137 int mlx4_WRITE_MTT_wrapper(struct mlx4_dev *dev, int slave,
2138                            struct mlx4_vhcr *vhcr,
2139                            struct mlx4_cmd_mailbox *inbox,
2140                            struct mlx4_cmd_mailbox *outbox,
2141                            struct mlx4_cmd_info *cmd)
2142 {
2143         struct mlx4_mtt mtt;
2144         __be64 *page_list = inbox->buf;
2145         u64 *pg_list = (u64 *)page_list;
2146         int i;
2147         struct res_mtt *rmtt = NULL;
2148         int start = be64_to_cpu(page_list[0]);
2149         int npages = vhcr->in_modifier;
2150         int err;
2151
2152         err = get_containing_mtt(dev, slave, start, npages, &rmtt);
2153         if (err)
2154                 return err;
2155
2156         /* Call the SW implementation of write_mtt:
2157          * - Prepare a dummy mtt struct
2158          * - Translate inbox contents to simple addresses in host endianess */
2159         mtt.offset = 0;  /* TBD this is broken but I don't handle it since
2160                             we don't really use it */
2161         mtt.order = 0;
2162         mtt.page_shift = 0;
2163         for (i = 0; i < npages; ++i)
2164                 pg_list[i + 2] = (be64_to_cpu(page_list[i + 2]) & ~1ULL);
2165
2166         err = __mlx4_write_mtt(dev, &mtt, be64_to_cpu(page_list[0]), npages,
2167                                ((u64 *)page_list + 2));
2168
2169         if (rmtt)
2170                 put_res(dev, slave, rmtt->com.res_id, RES_MTT);
2171
2172         return err;
2173 }
2174
2175 int mlx4_HW2SW_EQ_wrapper(struct mlx4_dev *dev, int slave,
2176                           struct mlx4_vhcr *vhcr,
2177                           struct mlx4_cmd_mailbox *inbox,
2178                           struct mlx4_cmd_mailbox *outbox,
2179                           struct mlx4_cmd_info *cmd)
2180 {
2181         int eqn = vhcr->in_modifier;
2182         int res_id = eqn | (slave << 8);
2183         struct res_eq *eq;
2184         int err;
2185
2186         err = eq_res_start_move_to(dev, slave, res_id, RES_EQ_RESERVED, &eq);
2187         if (err)
2188                 return err;
2189
2190         err = get_res(dev, slave, eq->mtt->com.res_id, RES_MTT, NULL);
2191         if (err)
2192                 goto ex_abort;
2193
2194         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2195         if (err)
2196                 goto ex_put;
2197
2198         atomic_dec(&eq->mtt->ref_count);
2199         put_res(dev, slave, eq->mtt->com.res_id, RES_MTT);
2200         res_end_move(dev, slave, RES_EQ, res_id);
2201         rem_res_range(dev, slave, res_id, 1, RES_EQ, 0);
2202
2203         return 0;
2204
2205 ex_put:
2206         put_res(dev, slave, eq->mtt->com.res_id, RES_MTT);
2207 ex_abort:
2208         res_abort_move(dev, slave, RES_EQ, res_id);
2209
2210         return err;
2211 }
2212
2213 int mlx4_GEN_EQE(struct mlx4_dev *dev, int slave, struct mlx4_eqe *eqe)
2214 {
2215         struct mlx4_priv *priv = mlx4_priv(dev);
2216         struct mlx4_slave_event_eq_info *event_eq;
2217         struct mlx4_cmd_mailbox *mailbox;
2218         u32 in_modifier = 0;
2219         int err;
2220         int res_id;
2221         struct res_eq *req;
2222
2223         if (!priv->mfunc.master.slave_state)
2224                 return -EINVAL;
2225
2226         event_eq = &priv->mfunc.master.slave_state[slave].event_eq[eqe->type];
2227
2228         /* Create the event only if the slave is registered */
2229         if (event_eq->eqn < 0)
2230                 return 0;
2231
2232         mutex_lock(&priv->mfunc.master.gen_eqe_mutex[slave]);
2233         res_id = (slave << 8) | event_eq->eqn;
2234         err = get_res(dev, slave, res_id, RES_EQ, &req);
2235         if (err)
2236                 goto unlock;
2237
2238         if (req->com.from_state != RES_EQ_HW) {
2239                 err = -EINVAL;
2240                 goto put;
2241         }
2242
2243         mailbox = mlx4_alloc_cmd_mailbox(dev);
2244         if (IS_ERR(mailbox)) {
2245                 err = PTR_ERR(mailbox);
2246                 goto put;
2247         }
2248
2249         if (eqe->type == MLX4_EVENT_TYPE_CMD) {
2250                 ++event_eq->token;
2251                 eqe->event.cmd.token = cpu_to_be16(event_eq->token);
2252         }
2253
2254         memcpy(mailbox->buf, (u8 *) eqe, 28);
2255
2256         in_modifier = (slave & 0xff) | ((event_eq->eqn & 0xff) << 16);
2257
2258         err = mlx4_cmd(dev, mailbox->dma, in_modifier, 0,
2259                        MLX4_CMD_GEN_EQE, MLX4_CMD_TIME_CLASS_B,
2260                        MLX4_CMD_NATIVE);
2261
2262         put_res(dev, slave, res_id, RES_EQ);
2263         mutex_unlock(&priv->mfunc.master.gen_eqe_mutex[slave]);
2264         mlx4_free_cmd_mailbox(dev, mailbox);
2265         return err;
2266
2267 put:
2268         put_res(dev, slave, res_id, RES_EQ);
2269
2270 unlock:
2271         mutex_unlock(&priv->mfunc.master.gen_eqe_mutex[slave]);
2272         return err;
2273 }
2274
2275 int mlx4_QUERY_EQ_wrapper(struct mlx4_dev *dev, int slave,
2276                           struct mlx4_vhcr *vhcr,
2277                           struct mlx4_cmd_mailbox *inbox,
2278                           struct mlx4_cmd_mailbox *outbox,
2279                           struct mlx4_cmd_info *cmd)
2280 {
2281         int eqn = vhcr->in_modifier;
2282         int res_id = eqn | (slave << 8);
2283         struct res_eq *eq;
2284         int err;
2285
2286         err = get_res(dev, slave, res_id, RES_EQ, &eq);
2287         if (err)
2288                 return err;
2289
2290         if (eq->com.from_state != RES_EQ_HW) {
2291                 err = -EINVAL;
2292                 goto ex_put;
2293         }
2294
2295         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2296
2297 ex_put:
2298         put_res(dev, slave, res_id, RES_EQ);
2299         return err;
2300 }
2301
2302 int mlx4_SW2HW_CQ_wrapper(struct mlx4_dev *dev, int slave,
2303                           struct mlx4_vhcr *vhcr,
2304                           struct mlx4_cmd_mailbox *inbox,
2305                           struct mlx4_cmd_mailbox *outbox,
2306                           struct mlx4_cmd_info *cmd)
2307 {
2308         int err;
2309         int cqn = vhcr->in_modifier;
2310         struct mlx4_cq_context *cqc = inbox->buf;
2311         int mtt_base = cq_get_mtt_addr(cqc) / dev->caps.mtt_entry_sz;
2312         struct res_cq *cq;
2313         struct res_mtt *mtt;
2314
2315         err = cq_res_start_move_to(dev, slave, cqn, RES_CQ_HW, &cq);
2316         if (err)
2317                 return err;
2318         err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
2319         if (err)
2320                 goto out_move;
2321         err = check_mtt_range(dev, slave, mtt_base, cq_get_mtt_size(cqc), mtt);
2322         if (err)
2323                 goto out_put;
2324         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2325         if (err)
2326                 goto out_put;
2327         atomic_inc(&mtt->ref_count);
2328         cq->mtt = mtt;
2329         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2330         res_end_move(dev, slave, RES_CQ, cqn);
2331         return 0;
2332
2333 out_put:
2334         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2335 out_move:
2336         res_abort_move(dev, slave, RES_CQ, cqn);
2337         return err;
2338 }
2339
2340 int mlx4_HW2SW_CQ_wrapper(struct mlx4_dev *dev, int slave,
2341                           struct mlx4_vhcr *vhcr,
2342                           struct mlx4_cmd_mailbox *inbox,
2343                           struct mlx4_cmd_mailbox *outbox,
2344                           struct mlx4_cmd_info *cmd)
2345 {
2346         int err;
2347         int cqn = vhcr->in_modifier;
2348         struct res_cq *cq;
2349
2350         err = cq_res_start_move_to(dev, slave, cqn, RES_CQ_ALLOCATED, &cq);
2351         if (err)
2352                 return err;
2353         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2354         if (err)
2355                 goto out_move;
2356         atomic_dec(&cq->mtt->ref_count);
2357         res_end_move(dev, slave, RES_CQ, cqn);
2358         return 0;
2359
2360 out_move:
2361         res_abort_move(dev, slave, RES_CQ, cqn);
2362         return err;
2363 }
2364
2365 int mlx4_QUERY_CQ_wrapper(struct mlx4_dev *dev, int slave,
2366                           struct mlx4_vhcr *vhcr,
2367                           struct mlx4_cmd_mailbox *inbox,
2368                           struct mlx4_cmd_mailbox *outbox,
2369                           struct mlx4_cmd_info *cmd)
2370 {
2371         int cqn = vhcr->in_modifier;
2372         struct res_cq *cq;
2373         int err;
2374
2375         err = get_res(dev, slave, cqn, RES_CQ, &cq);
2376         if (err)
2377                 return err;
2378
2379         if (cq->com.from_state != RES_CQ_HW)
2380                 goto ex_put;
2381
2382         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2383 ex_put:
2384         put_res(dev, slave, cqn, RES_CQ);
2385
2386         return err;
2387 }
2388
2389 static int handle_resize(struct mlx4_dev *dev, int slave,
2390                          struct mlx4_vhcr *vhcr,
2391                          struct mlx4_cmd_mailbox *inbox,
2392                          struct mlx4_cmd_mailbox *outbox,
2393                          struct mlx4_cmd_info *cmd,
2394                          struct res_cq *cq)
2395 {
2396         int err;
2397         struct res_mtt *orig_mtt;
2398         struct res_mtt *mtt;
2399         struct mlx4_cq_context *cqc = inbox->buf;
2400         int mtt_base = cq_get_mtt_addr(cqc) / dev->caps.mtt_entry_sz;
2401
2402         err = get_res(dev, slave, cq->mtt->com.res_id, RES_MTT, &orig_mtt);
2403         if (err)
2404                 return err;
2405
2406         if (orig_mtt != cq->mtt) {
2407                 err = -EINVAL;
2408                 goto ex_put;
2409         }
2410
2411         err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
2412         if (err)
2413                 goto ex_put;
2414
2415         err = check_mtt_range(dev, slave, mtt_base, cq_get_mtt_size(cqc), mtt);
2416         if (err)
2417                 goto ex_put1;
2418         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2419         if (err)
2420                 goto ex_put1;
2421         atomic_dec(&orig_mtt->ref_count);
2422         put_res(dev, slave, orig_mtt->com.res_id, RES_MTT);
2423         atomic_inc(&mtt->ref_count);
2424         cq->mtt = mtt;
2425         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2426         return 0;
2427
2428 ex_put1:
2429         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2430 ex_put:
2431         put_res(dev, slave, orig_mtt->com.res_id, RES_MTT);
2432
2433         return err;
2434
2435 }
2436
2437 int mlx4_MODIFY_CQ_wrapper(struct mlx4_dev *dev, int slave,
2438                            struct mlx4_vhcr *vhcr,
2439                            struct mlx4_cmd_mailbox *inbox,
2440                            struct mlx4_cmd_mailbox *outbox,
2441                            struct mlx4_cmd_info *cmd)
2442 {
2443         int cqn = vhcr->in_modifier;
2444         struct res_cq *cq;
2445         int err;
2446
2447         err = get_res(dev, slave, cqn, RES_CQ, &cq);
2448         if (err)
2449                 return err;
2450
2451         if (cq->com.from_state != RES_CQ_HW)
2452                 goto ex_put;
2453
2454         if (vhcr->op_modifier == 0) {
2455                 err = handle_resize(dev, slave, vhcr, inbox, outbox, cmd, cq);
2456                 goto ex_put;
2457         }
2458
2459         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2460 ex_put:
2461         put_res(dev, slave, cqn, RES_CQ);
2462
2463         return err;
2464 }
2465
2466 static int srq_get_mtt_size(struct mlx4_srq_context *srqc)
2467 {
2468         int log_srq_size = (be32_to_cpu(srqc->state_logsize_srqn) >> 24) & 0xf;
2469         int log_rq_stride = srqc->logstride & 7;
2470         int page_shift = (srqc->log_page_size & 0x3f) + 12;
2471
2472         if (log_srq_size + log_rq_stride + 4 < page_shift)
2473                 return 1;
2474
2475         return 1 << (log_srq_size + log_rq_stride + 4 - page_shift);
2476 }
2477
2478 int mlx4_SW2HW_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2479                            struct mlx4_vhcr *vhcr,
2480                            struct mlx4_cmd_mailbox *inbox,
2481                            struct mlx4_cmd_mailbox *outbox,
2482                            struct mlx4_cmd_info *cmd)
2483 {
2484         int err;
2485         int srqn = vhcr->in_modifier;
2486         struct res_mtt *mtt;
2487         struct res_srq *srq;
2488         struct mlx4_srq_context *srqc = inbox->buf;
2489         int mtt_base = srq_get_mtt_addr(srqc) / dev->caps.mtt_entry_sz;
2490
2491         if (srqn != (be32_to_cpu(srqc->state_logsize_srqn) & 0xffffff))
2492                 return -EINVAL;
2493
2494         err = srq_res_start_move_to(dev, slave, srqn, RES_SRQ_HW, &srq);
2495         if (err)
2496                 return err;
2497         err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
2498         if (err)
2499                 goto ex_abort;
2500         err = check_mtt_range(dev, slave, mtt_base, srq_get_mtt_size(srqc),
2501                               mtt);
2502         if (err)
2503                 goto ex_put_mtt;
2504
2505         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2506         if (err)
2507                 goto ex_put_mtt;
2508
2509         atomic_inc(&mtt->ref_count);
2510         srq->mtt = mtt;
2511         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2512         res_end_move(dev, slave, RES_SRQ, srqn);
2513         return 0;
2514
2515 ex_put_mtt:
2516         put_res(dev, slave, mtt->com.res_id, RES_MTT);
2517 ex_abort:
2518         res_abort_move(dev, slave, RES_SRQ, srqn);
2519
2520         return err;
2521 }
2522
2523 int mlx4_HW2SW_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2524                            struct mlx4_vhcr *vhcr,
2525                            struct mlx4_cmd_mailbox *inbox,
2526                            struct mlx4_cmd_mailbox *outbox,
2527                            struct mlx4_cmd_info *cmd)
2528 {
2529         int err;
2530         int srqn = vhcr->in_modifier;
2531         struct res_srq *srq;
2532
2533         err = srq_res_start_move_to(dev, slave, srqn, RES_SRQ_ALLOCATED, &srq);
2534         if (err)
2535                 return err;
2536         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2537         if (err)
2538                 goto ex_abort;
2539         atomic_dec(&srq->mtt->ref_count);
2540         if (srq->cq)
2541                 atomic_dec(&srq->cq->ref_count);
2542         res_end_move(dev, slave, RES_SRQ, srqn);
2543
2544         return 0;
2545
2546 ex_abort:
2547         res_abort_move(dev, slave, RES_SRQ, srqn);
2548
2549         return err;
2550 }
2551
2552 int mlx4_QUERY_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2553                            struct mlx4_vhcr *vhcr,
2554                            struct mlx4_cmd_mailbox *inbox,
2555                            struct mlx4_cmd_mailbox *outbox,
2556                            struct mlx4_cmd_info *cmd)
2557 {
2558         int err;
2559         int srqn = vhcr->in_modifier;
2560         struct res_srq *srq;
2561
2562         err = get_res(dev, slave, srqn, RES_SRQ, &srq);
2563         if (err)
2564                 return err;
2565         if (srq->com.from_state != RES_SRQ_HW) {
2566                 err = -EBUSY;
2567                 goto out;
2568         }
2569         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2570 out:
2571         put_res(dev, slave, srqn, RES_SRQ);
2572         return err;
2573 }
2574
2575 int mlx4_ARM_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2576                          struct mlx4_vhcr *vhcr,
2577                          struct mlx4_cmd_mailbox *inbox,
2578                          struct mlx4_cmd_mailbox *outbox,
2579                          struct mlx4_cmd_info *cmd)
2580 {
2581         int err;
2582         int srqn = vhcr->in_modifier;
2583         struct res_srq *srq;
2584
2585         err = get_res(dev, slave, srqn, RES_SRQ, &srq);
2586         if (err)
2587                 return err;
2588
2589         if (srq->com.from_state != RES_SRQ_HW) {
2590                 err = -EBUSY;
2591                 goto out;
2592         }
2593
2594         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2595 out:
2596         put_res(dev, slave, srqn, RES_SRQ);
2597         return err;
2598 }
2599
2600 int mlx4_GEN_QP_wrapper(struct mlx4_dev *dev, int slave,
2601                         struct mlx4_vhcr *vhcr,
2602                         struct mlx4_cmd_mailbox *inbox,
2603                         struct mlx4_cmd_mailbox *outbox,
2604                         struct mlx4_cmd_info *cmd)
2605 {
2606         int err;
2607         int qpn = vhcr->in_modifier & 0x7fffff;
2608         struct res_qp *qp;
2609
2610         err = get_res(dev, slave, qpn, RES_QP, &qp);
2611         if (err)
2612                 return err;
2613         if (qp->com.from_state != RES_QP_HW) {
2614                 err = -EBUSY;
2615                 goto out;
2616         }
2617
2618         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2619 out:
2620         put_res(dev, slave, qpn, RES_QP);
2621         return err;
2622 }
2623
2624 int mlx4_INIT2RTR_QP_wrapper(struct mlx4_dev *dev, int slave,
2625                              struct mlx4_vhcr *vhcr,
2626                              struct mlx4_cmd_mailbox *inbox,
2627                              struct mlx4_cmd_mailbox *outbox,
2628                              struct mlx4_cmd_info *cmd)
2629 {
2630         struct mlx4_qp_context *qpc = inbox->buf + 8;
2631
2632         update_ud_gid(dev, qpc, (u8)slave);
2633
2634         return mlx4_GEN_QP_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2635 }
2636
2637 int mlx4_2RST_QP_wrapper(struct mlx4_dev *dev, int slave,
2638                          struct mlx4_vhcr *vhcr,
2639                          struct mlx4_cmd_mailbox *inbox,
2640                          struct mlx4_cmd_mailbox *outbox,
2641                          struct mlx4_cmd_info *cmd)
2642 {
2643         int err;
2644         int qpn = vhcr->in_modifier & 0x7fffff;
2645         struct res_qp *qp;
2646
2647         err = qp_res_start_move_to(dev, slave, qpn, RES_QP_MAPPED, &qp, 0);
2648         if (err)
2649                 return err;
2650         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2651         if (err)
2652                 goto ex_abort;
2653
2654         atomic_dec(&qp->mtt->ref_count);
2655         atomic_dec(&qp->rcq->ref_count);
2656         atomic_dec(&qp->scq->ref_count);
2657         if (qp->srq)
2658                 atomic_dec(&qp->srq->ref_count);
2659         res_end_move(dev, slave, RES_QP, qpn);
2660         return 0;
2661
2662 ex_abort:
2663         res_abort_move(dev, slave, RES_QP, qpn);
2664
2665         return err;
2666 }
2667
2668 static struct res_gid *find_gid(struct mlx4_dev *dev, int slave,
2669                                 struct res_qp *rqp, u8 *gid)
2670 {
2671         struct res_gid *res;
2672
2673         list_for_each_entry(res, &rqp->mcg_list, list) {
2674                 if (!memcmp(res->gid, gid, 16))
2675                         return res;
2676         }
2677         return NULL;
2678 }
2679
2680 static int add_mcg_res(struct mlx4_dev *dev, int slave, struct res_qp *rqp,
2681                        u8 *gid, enum mlx4_protocol prot,
2682                        enum mlx4_steer_type steer)
2683 {
2684         struct res_gid *res;
2685         int err;
2686
2687         res = kzalloc(sizeof *res, GFP_KERNEL);
2688         if (!res)
2689                 return -ENOMEM;
2690
2691         spin_lock_irq(&rqp->mcg_spl);
2692         if (find_gid(dev, slave, rqp, gid)) {
2693                 kfree(res);
2694                 err = -EEXIST;
2695         } else {
2696                 memcpy(res->gid, gid, 16);
2697                 res->prot = prot;
2698                 res->steer = steer;
2699                 list_add_tail(&res->list, &rqp->mcg_list);
2700                 err = 0;
2701         }
2702         spin_unlock_irq(&rqp->mcg_spl);
2703
2704         return err;
2705 }
2706
2707 static int rem_mcg_res(struct mlx4_dev *dev, int slave, struct res_qp *rqp,
2708                        u8 *gid, enum mlx4_protocol prot,
2709                        enum mlx4_steer_type steer)
2710 {
2711         struct res_gid *res;
2712         int err;
2713
2714         spin_lock_irq(&rqp->mcg_spl);
2715         res = find_gid(dev, slave, rqp, gid);
2716         if (!res || res->prot != prot || res->steer != steer)
2717                 err = -EINVAL;
2718         else {
2719                 list_del(&res->list);
2720                 kfree(res);
2721                 err = 0;
2722         }
2723         spin_unlock_irq(&rqp->mcg_spl);
2724
2725         return err;
2726 }
2727
2728 int mlx4_QP_ATTACH_wrapper(struct mlx4_dev *dev, int slave,
2729                                struct mlx4_vhcr *vhcr,
2730                                struct mlx4_cmd_mailbox *inbox,
2731                                struct mlx4_cmd_mailbox *outbox,
2732                                struct mlx4_cmd_info *cmd)
2733 {
2734         struct mlx4_qp qp; /* dummy for calling attach/detach */
2735         u8 *gid = inbox->buf;
2736         enum mlx4_protocol prot = (vhcr->in_modifier >> 28) & 0x7;
2737         int err;
2738         int qpn;
2739         struct res_qp *rqp;
2740         int attach = vhcr->op_modifier;
2741         int block_loopback = vhcr->in_modifier >> 31;
2742         u8 steer_type_mask = 2;
2743         enum mlx4_steer_type type = (gid[7] & steer_type_mask) >> 1;
2744
2745         qpn = vhcr->in_modifier & 0xffffff;
2746         err = get_res(dev, slave, qpn, RES_QP, &rqp);
2747         if (err)
2748                 return err;
2749
2750         qp.qpn = qpn;
2751         if (attach) {
2752                 err = add_mcg_res(dev, slave, rqp, gid, prot, type);
2753                 if (err)
2754                         goto ex_put;
2755
2756                 err = mlx4_qp_attach_common(dev, &qp, gid,
2757                                             block_loopback, prot, type);
2758                 if (err)
2759                         goto ex_rem;
2760         } else {
2761                 err = rem_mcg_res(dev, slave, rqp, gid, prot, type);
2762                 if (err)
2763                         goto ex_put;
2764                 err = mlx4_qp_detach_common(dev, &qp, gid, prot, type);
2765         }
2766
2767         put_res(dev, slave, qpn, RES_QP);
2768         return 0;
2769
2770 ex_rem:
2771         /* ignore error return below, already in error */
2772         (void) rem_mcg_res(dev, slave, rqp, gid, prot, type);
2773 ex_put:
2774         put_res(dev, slave, qpn, RES_QP);
2775
2776         return err;
2777 }
2778
2779 int mlx4_QP_FLOW_STEERING_ATTACH_wrapper(struct mlx4_dev *dev, int slave,
2780                                          struct mlx4_vhcr *vhcr,
2781                                          struct mlx4_cmd_mailbox *inbox,
2782                                          struct mlx4_cmd_mailbox *outbox,
2783                                          struct mlx4_cmd_info *cmd)
2784 {
2785         int err;
2786
2787         if (dev->caps.steering_mode !=
2788             MLX4_STEERING_MODE_DEVICE_MANAGED)
2789                 return -EOPNOTSUPP;
2790
2791         err = mlx4_cmd_imm(dev, inbox->dma, &vhcr->out_param,
2792                            vhcr->in_modifier, 0,
2793                            MLX4_QP_FLOW_STEERING_ATTACH, MLX4_CMD_TIME_CLASS_A,
2794                            MLX4_CMD_NATIVE);
2795         if (err)
2796                 return err;
2797
2798         err = add_res_range(dev, slave, vhcr->out_param, 1, RES_FS_RULE, 0);
2799         if (err) {
2800                 mlx4_err(dev, "Fail to add flow steering resources.\n ");
2801                 /* detach rule*/
2802                 mlx4_cmd(dev, vhcr->out_param, 0, 0,
2803                          MLX4_QP_FLOW_STEERING_ATTACH, MLX4_CMD_TIME_CLASS_A,
2804                          MLX4_CMD_NATIVE);
2805         }
2806         return err;
2807 }
2808
2809 int mlx4_QP_FLOW_STEERING_DETACH_wrapper(struct mlx4_dev *dev, int slave,
2810                                          struct mlx4_vhcr *vhcr,
2811                                          struct mlx4_cmd_mailbox *inbox,
2812                                          struct mlx4_cmd_mailbox *outbox,
2813                                          struct mlx4_cmd_info *cmd)
2814 {
2815         int err;
2816
2817         if (dev->caps.steering_mode !=
2818             MLX4_STEERING_MODE_DEVICE_MANAGED)
2819                 return -EOPNOTSUPP;
2820
2821         err = rem_res_range(dev, slave, vhcr->in_param, 1, RES_FS_RULE, 0);
2822         if (err) {
2823                 mlx4_err(dev, "Fail to remove flow steering resources.\n ");
2824                 return err;
2825         }
2826
2827         err = mlx4_cmd(dev, vhcr->in_param, 0, 0,
2828                        MLX4_QP_FLOW_STEERING_DETACH, MLX4_CMD_TIME_CLASS_A,
2829                        MLX4_CMD_NATIVE);
2830         return err;
2831 }
2832
2833 enum {
2834         BUSY_MAX_RETRIES = 10
2835 };
2836
2837 int mlx4_QUERY_IF_STAT_wrapper(struct mlx4_dev *dev, int slave,
2838                                struct mlx4_vhcr *vhcr,
2839                                struct mlx4_cmd_mailbox *inbox,
2840                                struct mlx4_cmd_mailbox *outbox,
2841                                struct mlx4_cmd_info *cmd)
2842 {
2843         int err;
2844         int index = vhcr->in_modifier & 0xffff;
2845
2846         err = get_res(dev, slave, index, RES_COUNTER, NULL);
2847         if (err)
2848                 return err;
2849
2850         err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2851         put_res(dev, slave, index, RES_COUNTER);
2852         return err;
2853 }
2854
2855 static void detach_qp(struct mlx4_dev *dev, int slave, struct res_qp *rqp)
2856 {
2857         struct res_gid *rgid;
2858         struct res_gid *tmp;
2859         struct mlx4_qp qp; /* dummy for calling attach/detach */
2860
2861         list_for_each_entry_safe(rgid, tmp, &rqp->mcg_list, list) {
2862                 qp.qpn = rqp->local_qpn;
2863                 (void) mlx4_qp_detach_common(dev, &qp, rgid->gid, rgid->prot,
2864                                              rgid->steer);
2865                 list_del(&rgid->list);
2866                 kfree(rgid);
2867         }
2868 }
2869
2870 static int _move_all_busy(struct mlx4_dev *dev, int slave,
2871                           enum mlx4_resource type, int print)
2872 {
2873         struct mlx4_priv *priv = mlx4_priv(dev);
2874         struct mlx4_resource_tracker *tracker =
2875                 &priv->mfunc.master.res_tracker;
2876         struct list_head *rlist = &tracker->slave_list[slave].res_list[type];
2877         struct res_common *r;
2878         struct res_common *tmp;
2879         int busy;
2880
2881         busy = 0;
2882         spin_lock_irq(mlx4_tlock(dev));
2883         list_for_each_entry_safe(r, tmp, rlist, list) {
2884                 if (r->owner == slave) {
2885                         if (!r->removing) {
2886                                 if (r->state == RES_ANY_BUSY) {
2887                                         if (print)
2888                                                 mlx4_dbg(dev,
2889                                                          "%s id 0x%llx is busy\n",
2890                                                           ResourceType(type),
2891                                                           r->res_id);
2892                                         ++busy;
2893                                 } else {
2894                                         r->from_state = r->state;
2895                                         r->state = RES_ANY_BUSY;
2896                                         r->removing = 1;
2897                                 }
2898                         }
2899                 }
2900         }
2901         spin_unlock_irq(mlx4_tlock(dev));
2902
2903         return busy;
2904 }
2905
2906 static int move_all_busy(struct mlx4_dev *dev, int slave,
2907                          enum mlx4_resource type)
2908 {
2909         unsigned long begin;
2910         int busy;
2911
2912         begin = jiffies;
2913         do {
2914                 busy = _move_all_busy(dev, slave, type, 0);
2915                 if (time_after(jiffies, begin + 5 * HZ))
2916                         break;
2917                 if (busy)
2918                         cond_resched();
2919         } while (busy);
2920
2921         if (busy)
2922                 busy = _move_all_busy(dev, slave, type, 1);
2923
2924         return busy;
2925 }
2926 static void rem_slave_qps(struct mlx4_dev *dev, int slave)
2927 {
2928         struct mlx4_priv *priv = mlx4_priv(dev);
2929         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
2930         struct list_head *qp_list =
2931                 &tracker->slave_list[slave].res_list[RES_QP];
2932         struct res_qp *qp;
2933         struct res_qp *tmp;
2934         int state;
2935         u64 in_param;
2936         int qpn;
2937         int err;
2938
2939         err = move_all_busy(dev, slave, RES_QP);
2940         if (err)
2941                 mlx4_warn(dev, "rem_slave_qps: Could not move all qps to busy"
2942                           "for slave %d\n", slave);
2943
2944         spin_lock_irq(mlx4_tlock(dev));
2945         list_for_each_entry_safe(qp, tmp, qp_list, com.list) {
2946                 spin_unlock_irq(mlx4_tlock(dev));
2947                 if (qp->com.owner == slave) {
2948                         qpn = qp->com.res_id;
2949                         detach_qp(dev, slave, qp);
2950                         state = qp->com.from_state;
2951                         while (state != 0) {
2952                                 switch (state) {
2953                                 case RES_QP_RESERVED:
2954                                         spin_lock_irq(mlx4_tlock(dev));
2955                                         rb_erase(&qp->com.node,
2956                                                  &tracker->res_tree[RES_QP]);
2957                                         list_del(&qp->com.list);
2958                                         spin_unlock_irq(mlx4_tlock(dev));
2959                                         kfree(qp);
2960                                         state = 0;
2961                                         break;
2962                                 case RES_QP_MAPPED:
2963                                         if (!valid_reserved(dev, slave, qpn))
2964                                                 __mlx4_qp_free_icm(dev, qpn);
2965                                         state = RES_QP_RESERVED;
2966                                         break;
2967                                 case RES_QP_HW:
2968                                         in_param = slave;
2969                                         err = mlx4_cmd(dev, in_param,
2970                                                        qp->local_qpn, 2,
2971                                                        MLX4_CMD_2RST_QP,
2972                                                        MLX4_CMD_TIME_CLASS_A,
2973                                                        MLX4_CMD_NATIVE);
2974                                         if (err)
2975                                                 mlx4_dbg(dev, "rem_slave_qps: failed"
2976                                                          " to move slave %d qpn %d to"
2977                                                          " reset\n", slave,
2978                                                          qp->local_qpn);
2979                                         atomic_dec(&qp->rcq->ref_count);
2980                                         atomic_dec(&qp->scq->ref_count);
2981                                         atomic_dec(&qp->mtt->ref_count);
2982                                         if (qp->srq)
2983                                                 atomic_dec(&qp->srq->ref_count);
2984                                         state = RES_QP_MAPPED;
2985                                         break;
2986                                 default:
2987                                         state = 0;
2988                                 }
2989                         }
2990                 }
2991                 spin_lock_irq(mlx4_tlock(dev));
2992         }
2993         spin_unlock_irq(mlx4_tlock(dev));
2994 }
2995
2996 static void rem_slave_srqs(struct mlx4_dev *dev, int slave)
2997 {
2998         struct mlx4_priv *priv = mlx4_priv(dev);
2999         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
3000         struct list_head *srq_list =
3001                 &tracker->slave_list[slave].res_list[RES_SRQ];
3002         struct res_srq *srq;
3003         struct res_srq *tmp;
3004         int state;
3005         u64 in_param;
3006         LIST_HEAD(tlist);
3007         int srqn;
3008         int err;
3009
3010         err = move_all_busy(dev, slave, RES_SRQ);
3011         if (err)
3012                 mlx4_warn(dev, "rem_slave_srqs: Could not move all srqs to "
3013                           "busy for slave %d\n", slave);
3014
3015         spin_lock_irq(mlx4_tlock(dev));
3016         list_for_each_entry_safe(srq, tmp, srq_list, com.list) {
3017                 spin_unlock_irq(mlx4_tlock(dev));
3018                 if (srq->com.owner == slave) {
3019                         srqn = srq->com.res_id;
3020                         state = srq->com.from_state;
3021                         while (state != 0) {
3022                                 switch (state) {
3023                                 case RES_SRQ_ALLOCATED:
3024                                         __mlx4_srq_free_icm(dev, srqn);
3025                                         spin_lock_irq(mlx4_tlock(dev));
3026                                         rb_erase(&srq->com.node,
3027                                                  &tracker->res_tree[RES_SRQ]);
3028                                         list_del(&srq->com.list);
3029                                         spin_unlock_irq(mlx4_tlock(dev));
3030                                         kfree(srq);
3031                                         state = 0;
3032                                         break;
3033
3034                                 case RES_SRQ_HW:
3035                                         in_param = slave;
3036                                         err = mlx4_cmd(dev, in_param, srqn, 1,
3037                                                        MLX4_CMD_HW2SW_SRQ,
3038                                                        MLX4_CMD_TIME_CLASS_A,
3039                                                        MLX4_CMD_NATIVE);
3040                                         if (err)
3041                                                 mlx4_dbg(dev, "rem_slave_srqs: failed"
3042                                                          " to move slave %d srq %d to"
3043                                                          " SW ownership\n",
3044                                                          slave, srqn);
3045
3046                                         atomic_dec(&srq->mtt->ref_count);
3047                                         if (srq->cq)
3048                                                 atomic_dec(&srq->cq->ref_count);
3049                                         state = RES_SRQ_ALLOCATED;
3050                                         break;
3051
3052                                 default:
3053                                         state = 0;
3054                                 }
3055                         }
3056                 }
3057                 spin_lock_irq(mlx4_tlock(dev));
3058         }
3059         spin_unlock_irq(mlx4_tlock(dev));
3060 }
3061
3062 static void rem_slave_cqs(struct mlx4_dev *dev, int slave)
3063 {
3064         struct mlx4_priv *priv = mlx4_priv(dev);
3065         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
3066         struct list_head *cq_list =
3067                 &tracker->slave_list[slave].res_list[RES_CQ];
3068         struct res_cq *cq;
3069         struct res_cq *tmp;
3070         int state;
3071         u64 in_param;
3072         LIST_HEAD(tlist);
3073         int cqn;
3074         int err;
3075
3076         err = move_all_busy(dev, slave, RES_CQ);
3077         if (err)
3078                 mlx4_warn(dev, "rem_slave_cqs: Could not move all cqs to "
3079                           "busy for slave %d\n", slave);
3080
3081         spin_lock_irq(mlx4_tlock(dev));
3082         list_for_each_entry_safe(cq, tmp, cq_list, com.list) {
3083                 spin_unlock_irq(mlx4_tlock(dev));
3084                 if (cq->com.owner == slave && !atomic_read(&cq->ref_count)) {
3085                         cqn = cq->com.res_id;
3086                         state = cq->com.from_state;
3087                         while (state != 0) {
3088                                 switch (state) {
3089                                 case RES_CQ_ALLOCATED:
3090                                         __mlx4_cq_free_icm(dev, cqn);
3091                                         spin_lock_irq(mlx4_tlock(dev));
3092                                         rb_erase(&cq->com.node,
3093                                                  &tracker->res_tree[RES_CQ]);
3094                                         list_del(&cq->com.list);
3095                                         spin_unlock_irq(mlx4_tlock(dev));
3096                                         kfree(cq);
3097                                         state = 0;
3098                                         break;
3099
3100                                 case RES_CQ_HW:
3101                                         in_param = slave;
3102                                         err = mlx4_cmd(dev, in_param, cqn, 1,
3103                                                        MLX4_CMD_HW2SW_CQ,
3104                                                        MLX4_CMD_TIME_CLASS_A,
3105                                                        MLX4_CMD_NATIVE);
3106                                         if (err)
3107                                                 mlx4_dbg(dev, "rem_slave_cqs: failed"
3108                                                          " to move slave %d cq %d to"
3109                                                          " SW ownership\n",
3110                                                          slave, cqn);
3111                                         atomic_dec(&cq->mtt->ref_count);
3112                                         state = RES_CQ_ALLOCATED;
3113                                         break;
3114
3115                                 default:
3116                                         state = 0;
3117                                 }
3118                         }
3119                 }
3120                 spin_lock_irq(mlx4_tlock(dev));
3121         }
3122         spin_unlock_irq(mlx4_tlock(dev));
3123 }
3124
3125 static void rem_slave_mrs(struct mlx4_dev *dev, int slave)
3126 {
3127         struct mlx4_priv *priv = mlx4_priv(dev);
3128         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
3129         struct list_head *mpt_list =
3130                 &tracker->slave_list[slave].res_list[RES_MPT];
3131         struct res_mpt *mpt;
3132         struct res_mpt *tmp;
3133         int state;
3134         u64 in_param;
3135         LIST_HEAD(tlist);
3136         int mptn;
3137         int err;
3138
3139         err = move_all_busy(dev, slave, RES_MPT);
3140         if (err)
3141                 mlx4_warn(dev, "rem_slave_mrs: Could not move all mpts to "
3142                           "busy for slave %d\n", slave);
3143
3144         spin_lock_irq(mlx4_tlock(dev));
3145         list_for_each_entry_safe(mpt, tmp, mpt_list, com.list) {
3146                 spin_unlock_irq(mlx4_tlock(dev));
3147                 if (mpt->com.owner == slave) {
3148                         mptn = mpt->com.res_id;
3149                         state = mpt->com.from_state;
3150                         while (state != 0) {
3151                                 switch (state) {
3152                                 case RES_MPT_RESERVED:
3153                                         __mlx4_mr_release(dev, mpt->key);
3154                                         spin_lock_irq(mlx4_tlock(dev));
3155                                         rb_erase(&mpt->com.node,
3156                                                  &tracker->res_tree[RES_MPT]);
3157                                         list_del(&mpt->com.list);
3158                                         spin_unlock_irq(mlx4_tlock(dev));
3159                                         kfree(mpt);
3160                                         state = 0;
3161                                         break;
3162
3163                                 case RES_MPT_MAPPED:
3164                                         __mlx4_mr_free_icm(dev, mpt->key);
3165                                         state = RES_MPT_RESERVED;
3166                                         break;
3167
3168                                 case RES_MPT_HW:
3169                                         in_param = slave;
3170                                         err = mlx4_cmd(dev, in_param, mptn, 0,
3171                                                      MLX4_CMD_HW2SW_MPT,
3172                                                      MLX4_CMD_TIME_CLASS_A,
3173                                                      MLX4_CMD_NATIVE);
3174                                         if (err)
3175                                                 mlx4_dbg(dev, "rem_slave_mrs: failed"
3176                                                          " to move slave %d mpt %d to"
3177                                                          " SW ownership\n",
3178                                                          slave, mptn);
3179                                         if (mpt->mtt)
3180                                                 atomic_dec(&mpt->mtt->ref_count);
3181                                         state = RES_MPT_MAPPED;
3182                                         break;
3183                                 default:
3184                                         state = 0;
3185                                 }
3186                         }
3187                 }
3188                 spin_lock_irq(mlx4_tlock(dev));
3189         }
3190         spin_unlock_irq(mlx4_tlock(dev));
3191 }
3192
3193 static void rem_slave_mtts(struct mlx4_dev *dev, int slave)
3194 {
3195         struct mlx4_priv *priv = mlx4_priv(dev);
3196         struct mlx4_resource_tracker *tracker =
3197                 &priv->mfunc.master.res_tracker;
3198         struct list_head *mtt_list =
3199                 &tracker->slave_list[slave].res_list[RES_MTT];
3200         struct res_mtt *mtt;
3201         struct res_mtt *tmp;
3202         int state;
3203         LIST_HEAD(tlist);
3204         int base;
3205         int err;
3206
3207         err = move_all_busy(dev, slave, RES_MTT);
3208         if (err)
3209                 mlx4_warn(dev, "rem_slave_mtts: Could not move all mtts to "
3210                           "busy for slave %d\n", slave);
3211
3212         spin_lock_irq(mlx4_tlock(dev));
3213         list_for_each_entry_safe(mtt, tmp, mtt_list, com.list) {
3214                 spin_unlock_irq(mlx4_tlock(dev));
3215                 if (mtt->com.owner == slave) {
3216                         base = mtt->com.res_id;
3217                         state = mtt->com.from_state;
3218                         while (state != 0) {
3219                                 switch (state) {
3220                                 case RES_MTT_ALLOCATED:
3221                                         __mlx4_free_mtt_range(dev, base,
3222                                                               mtt->order);
3223                                         spin_lock_irq(mlx4_tlock(dev));
3224                                         rb_erase(&mtt->com.node,
3225                                                  &tracker->res_tree[RES_MTT]);
3226                                         list_del(&mtt->com.list);
3227                                         spin_unlock_irq(mlx4_tlock(dev));
3228                                         kfree(mtt);
3229                                         state = 0;
3230                                         break;
3231
3232                                 default:
3233                                         state = 0;
3234                                 }
3235                         }
3236                 }
3237                 spin_lock_irq(mlx4_tlock(dev));
3238         }
3239         spin_unlock_irq(mlx4_tlock(dev));
3240 }
3241
3242 static void rem_slave_fs_rule(struct mlx4_dev *dev, int slave)
3243 {
3244         struct mlx4_priv *priv = mlx4_priv(dev);
3245         struct mlx4_resource_tracker *tracker =
3246                 &priv->mfunc.master.res_tracker;
3247         struct list_head *fs_rule_list =
3248                 &tracker->slave_list[slave].res_list[RES_FS_RULE];
3249         struct res_fs_rule *fs_rule;
3250         struct res_fs_rule *tmp;
3251         int state;
3252         u64 base;
3253         int err;
3254
3255         err = move_all_busy(dev, slave, RES_FS_RULE);
3256         if (err)
3257                 mlx4_warn(dev, "rem_slave_fs_rule: Could not move all mtts to busy for slave %d\n",
3258                           slave);
3259
3260         spin_lock_irq(mlx4_tlock(dev));
3261         list_for_each_entry_safe(fs_rule, tmp, fs_rule_list, com.list) {
3262                 spin_unlock_irq(mlx4_tlock(dev));
3263                 if (fs_rule->com.owner == slave) {
3264                         base = fs_rule->com.res_id;
3265                         state = fs_rule->com.from_state;
3266                         while (state != 0) {
3267                                 switch (state) {
3268                                 case RES_FS_RULE_ALLOCATED:
3269                                         /* detach rule */
3270                                         err = mlx4_cmd(dev, base, 0, 0,
3271                                                        MLX4_QP_FLOW_STEERING_DETACH,
3272                                                        MLX4_CMD_TIME_CLASS_A,
3273                                                        MLX4_CMD_NATIVE);
3274
3275                                         spin_lock_irq(mlx4_tlock(dev));
3276                                         rb_erase(&fs_rule->com.node,
3277                                                  &tracker->res_tree[RES_FS_RULE]);
3278                                         list_del(&fs_rule->com.list);
3279                                         spin_unlock_irq(mlx4_tlock(dev));
3280                                         kfree(fs_rule);
3281                                         state = 0;
3282                                         break;
3283
3284                                 default:
3285                                         state = 0;
3286                                 }
3287                         }
3288                 }
3289                 spin_lock_irq(mlx4_tlock(dev));
3290         }
3291         spin_unlock_irq(mlx4_tlock(dev));
3292 }
3293
3294 static void rem_slave_eqs(struct mlx4_dev *dev, int slave)
3295 {
3296         struct mlx4_priv *priv = mlx4_priv(dev);
3297         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
3298         struct list_head *eq_list =
3299                 &tracker->slave_list[slave].res_list[RES_EQ];
3300         struct res_eq *eq;
3301         struct res_eq *tmp;
3302         int err;
3303         int state;
3304         LIST_HEAD(tlist);
3305         int eqn;
3306         struct mlx4_cmd_mailbox *mailbox;
3307
3308         err = move_all_busy(dev, slave, RES_EQ);
3309         if (err)
3310                 mlx4_warn(dev, "rem_slave_eqs: Could not move all eqs to "
3311                           "busy for slave %d\n", slave);
3312
3313         spin_lock_irq(mlx4_tlock(dev));
3314         list_for_each_entry_safe(eq, tmp, eq_list, com.list) {
3315                 spin_unlock_irq(mlx4_tlock(dev));
3316                 if (eq->com.owner == slave) {
3317                         eqn = eq->com.res_id;
3318                         state = eq->com.from_state;
3319                         while (state != 0) {
3320                                 switch (state) {
3321                                 case RES_EQ_RESERVED:
3322                                         spin_lock_irq(mlx4_tlock(dev));
3323                                         rb_erase(&eq->com.node,
3324                                                  &tracker->res_tree[RES_EQ]);
3325                                         list_del(&eq->com.list);
3326                                         spin_unlock_irq(mlx4_tlock(dev));
3327                                         kfree(eq);
3328                                         state = 0;
3329                                         break;
3330
3331                                 case RES_EQ_HW:
3332                                         mailbox = mlx4_alloc_cmd_mailbox(dev);
3333                                         if (IS_ERR(mailbox)) {
3334                                                 cond_resched();
3335                                                 continue;
3336                                         }
3337                                         err = mlx4_cmd_box(dev, slave, 0,
3338                                                            eqn & 0xff, 0,
3339                                                            MLX4_CMD_HW2SW_EQ,
3340                                                            MLX4_CMD_TIME_CLASS_A,
3341                                                            MLX4_CMD_NATIVE);
3342                                         if (err)
3343                                                 mlx4_dbg(dev, "rem_slave_eqs: failed"
3344                                                          " to move slave %d eqs %d to"
3345                                                          " SW ownership\n", slave, eqn);
3346                                         mlx4_free_cmd_mailbox(dev, mailbox);
3347                                         atomic_dec(&eq->mtt->ref_count);
3348                                         state = RES_EQ_RESERVED;
3349                                         break;
3350
3351                                 default:
3352                                         state = 0;
3353                                 }
3354                         }
3355                 }
3356                 spin_lock_irq(mlx4_tlock(dev));
3357         }
3358         spin_unlock_irq(mlx4_tlock(dev));
3359 }
3360
3361 static void rem_slave_counters(struct mlx4_dev *dev, int slave)
3362 {
3363         struct mlx4_priv *priv = mlx4_priv(dev);
3364         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
3365         struct list_head *counter_list =
3366                 &tracker->slave_list[slave].res_list[RES_COUNTER];
3367         struct res_counter *counter;
3368         struct res_counter *tmp;
3369         int err;
3370         int index;
3371
3372         err = move_all_busy(dev, slave, RES_COUNTER);
3373         if (err)
3374                 mlx4_warn(dev, "rem_slave_counters: Could not move all counters to "
3375                           "busy for slave %d\n", slave);
3376
3377         spin_lock_irq(mlx4_tlock(dev));
3378         list_for_each_entry_safe(counter, tmp, counter_list, com.list) {
3379                 if (counter->com.owner == slave) {
3380                         index = counter->com.res_id;
3381                         rb_erase(&counter->com.node,
3382                                  &tracker->res_tree[RES_COUNTER]);
3383                         list_del(&counter->com.list);
3384                         kfree(counter);
3385                         __mlx4_counter_free(dev, index);
3386                 }
3387         }
3388         spin_unlock_irq(mlx4_tlock(dev));
3389 }
3390
3391 static void rem_slave_xrcdns(struct mlx4_dev *dev, int slave)
3392 {
3393         struct mlx4_priv *priv = mlx4_priv(dev);
3394         struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
3395         struct list_head *xrcdn_list =
3396                 &tracker->slave_list[slave].res_list[RES_XRCD];
3397         struct res_xrcdn *xrcd;
3398         struct res_xrcdn *tmp;
3399         int err;
3400         int xrcdn;
3401
3402         err = move_all_busy(dev, slave, RES_XRCD);
3403         if (err)
3404                 mlx4_warn(dev, "rem_slave_xrcdns: Could not move all xrcdns to "
3405                           "busy for slave %d\n", slave);
3406
3407         spin_lock_irq(mlx4_tlock(dev));
3408         list_for_each_entry_safe(xrcd, tmp, xrcdn_list, com.list) {
3409                 if (xrcd->com.owner == slave) {
3410                         xrcdn = xrcd->com.res_id;
3411                         rb_erase(&xrcd->com.node, &tracker->res_tree[RES_XRCD]);
3412                         list_del(&xrcd->com.list);
3413                         kfree(xrcd);
3414                         __mlx4_xrcd_free(dev, xrcdn);
3415                 }
3416         }
3417         spin_unlock_irq(mlx4_tlock(dev));
3418 }
3419
3420 void mlx4_delete_all_resources_for_slave(struct mlx4_dev *dev, int slave)
3421 {
3422         struct mlx4_priv *priv = mlx4_priv(dev);
3423
3424         mutex_lock(&priv->mfunc.master.res_tracker.slave_list[slave].mutex);
3425         /*VLAN*/
3426         rem_slave_macs(dev, slave);
3427         rem_slave_qps(dev, slave);
3428         rem_slave_srqs(dev, slave);
3429         rem_slave_cqs(dev, slave);
3430         rem_slave_mrs(dev, slave);
3431         rem_slave_eqs(dev, slave);
3432         rem_slave_mtts(dev, slave);
3433         rem_slave_counters(dev, slave);
3434         rem_slave_xrcdns(dev, slave);
3435         rem_slave_fs_rule(dev, slave);
3436         mutex_unlock(&priv->mfunc.master.res_tracker.slave_list[slave].mutex);
3437 }