2 * Copyright (c) 2004, 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005, 2006, 2007, 2008 Mellanox Technologies.
5 * Copyright (c) 2005, 2006, 2007 Cisco Systems, Inc. All rights reserved.
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:
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
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.
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
36 #include <linux/sched.h>
37 #include <linux/pci.h>
38 #include <linux/errno.h>
39 #include <linux/kernel.h>
41 #include <linux/slab.h>
42 #include <linux/mlx4/cmd.h>
43 #include <linux/mlx4/qp.h>
48 #define MLX4_MAC_VALID (1ull << 63)
49 #define MLX4_MAC_MASK 0x7fffffffffffffffULL
53 struct list_head list;
59 struct list_head list;
73 struct list_head list;
75 enum mlx4_protocol prot;
79 RES_QP_BUSY = RES_ANY_BUSY,
81 /* QP number was allocated */
84 /* ICM memory for QP context was mapped */
87 /* QP is in hw ownership */
91 static inline const char *qp_states_str(enum res_qp_states state)
94 case RES_QP_BUSY: return "RES_QP_BUSY";
95 case RES_QP_RESERVED: return "RES_QP_RESERVED";
96 case RES_QP_MAPPED: return "RES_QP_MAPPED";
97 case RES_QP_HW: return "RES_QP_HW";
98 default: return "Unknown";
103 struct res_common com;
108 struct list_head mcg_list;
113 enum res_mtt_states {
114 RES_MTT_BUSY = RES_ANY_BUSY,
118 static inline const char *mtt_states_str(enum res_mtt_states state)
121 case RES_MTT_BUSY: return "RES_MTT_BUSY";
122 case RES_MTT_ALLOCATED: return "RES_MTT_ALLOCATED";
123 default: return "Unknown";
128 struct res_common com;
133 enum res_mpt_states {
134 RES_MPT_BUSY = RES_ANY_BUSY,
141 struct res_common com;
147 RES_EQ_BUSY = RES_ANY_BUSY,
153 struct res_common com;
158 RES_CQ_BUSY = RES_ANY_BUSY,
164 struct res_common com;
169 enum res_srq_states {
170 RES_SRQ_BUSY = RES_ANY_BUSY,
175 static inline const char *srq_states_str(enum res_srq_states state)
178 case RES_SRQ_BUSY: return "RES_SRQ_BUSY";
179 case RES_SRQ_ALLOCATED: return "RES_SRQ_ALLOCATED";
180 case RES_SRQ_HW: return "RES_SRQ_HW";
181 default: return "Unknown";
186 struct res_common com;
192 enum res_counter_states {
193 RES_COUNTER_BUSY = RES_ANY_BUSY,
194 RES_COUNTER_ALLOCATED,
197 static inline const char *counter_states_str(enum res_counter_states state)
200 case RES_COUNTER_BUSY: return "RES_COUNTER_BUSY";
201 case RES_COUNTER_ALLOCATED: return "RES_COUNTER_ALLOCATED";
202 default: return "Unknown";
207 struct res_common com;
212 static const char *ResourceType(enum mlx4_resource rt)
215 case RES_QP: return "RES_QP";
216 case RES_CQ: return "RES_CQ";
217 case RES_SRQ: return "RES_SRQ";
218 case RES_MPT: return "RES_MPT";
219 case RES_MTT: return "RES_MTT";
220 case RES_MAC: return "RES_MAC";
221 case RES_EQ: return "RES_EQ";
222 case RES_COUNTER: return "RES_COUNTER";
223 default: return "Unknown resource type !!!";
227 int mlx4_init_resource_tracker(struct mlx4_dev *dev)
229 struct mlx4_priv *priv = mlx4_priv(dev);
233 priv->mfunc.master.res_tracker.slave_list =
234 kzalloc(dev->num_slaves * sizeof(struct slave_list),
236 if (!priv->mfunc.master.res_tracker.slave_list)
239 for (i = 0 ; i < dev->num_slaves; i++) {
240 for (t = 0; t < MLX4_NUM_OF_RESOURCE_TYPE; ++t)
241 INIT_LIST_HEAD(&priv->mfunc.master.res_tracker.
242 slave_list[i].res_list[t]);
243 mutex_init(&priv->mfunc.master.res_tracker.slave_list[i].mutex);
246 mlx4_dbg(dev, "Started init_resource_tracker: %ld slaves\n",
248 for (i = 0 ; i < MLX4_NUM_OF_RESOURCE_TYPE; i++)
249 INIT_RADIX_TREE(&priv->mfunc.master.res_tracker.res_tree[i],
250 GFP_ATOMIC|__GFP_NOWARN);
252 spin_lock_init(&priv->mfunc.master.res_tracker.lock);
256 void mlx4_free_resource_tracker(struct mlx4_dev *dev)
258 struct mlx4_priv *priv = mlx4_priv(dev);
261 if (priv->mfunc.master.res_tracker.slave_list) {
262 for (i = 0 ; i < dev->num_slaves; i++)
263 mlx4_delete_all_resources_for_slave(dev, i);
265 kfree(priv->mfunc.master.res_tracker.slave_list);
269 static void update_ud_gid(struct mlx4_dev *dev,
270 struct mlx4_qp_context *qp_ctx, u8 slave)
272 u32 ts = (be32_to_cpu(qp_ctx->flags) >> 16) & 0xff;
274 if (MLX4_QP_ST_UD == ts)
275 qp_ctx->pri_path.mgid_index = 0x80 | slave;
277 mlx4_dbg(dev, "slave %d, new gid index: 0x%x ",
278 slave, qp_ctx->pri_path.mgid_index);
281 static int mpt_mask(struct mlx4_dev *dev)
283 return dev->caps.num_mpts - 1;
286 static void *find_res(struct mlx4_dev *dev, int res_id,
287 enum mlx4_resource type)
289 struct mlx4_priv *priv = mlx4_priv(dev);
291 return radix_tree_lookup(&priv->mfunc.master.res_tracker.res_tree[type],
295 static int get_res(struct mlx4_dev *dev, int slave, int res_id,
296 enum mlx4_resource type,
299 struct res_common *r;
302 spin_lock_irq(mlx4_tlock(dev));
303 r = find_res(dev, res_id, type);
309 if (r->state == RES_ANY_BUSY) {
314 if (r->owner != slave) {
319 r->from_state = r->state;
320 r->state = RES_ANY_BUSY;
321 mlx4_dbg(dev, "res %s id 0x%x to busy\n",
322 ResourceType(type), r->res_id);
325 *((struct res_common **)res) = r;
328 spin_unlock_irq(mlx4_tlock(dev));
332 int mlx4_get_slave_from_resource_id(struct mlx4_dev *dev,
333 enum mlx4_resource type,
334 int res_id, int *slave)
337 struct res_common *r;
343 spin_lock(mlx4_tlock(dev));
345 r = find_res(dev, id, type);
350 spin_unlock(mlx4_tlock(dev));
355 static void put_res(struct mlx4_dev *dev, int slave, int res_id,
356 enum mlx4_resource type)
358 struct res_common *r;
360 spin_lock_irq(mlx4_tlock(dev));
361 r = find_res(dev, res_id, type);
363 r->state = r->from_state;
364 spin_unlock_irq(mlx4_tlock(dev));
367 static struct res_common *alloc_qp_tr(int id)
371 ret = kzalloc(sizeof *ret, GFP_KERNEL);
375 ret->com.res_id = id;
376 ret->com.state = RES_QP_RESERVED;
377 INIT_LIST_HEAD(&ret->mcg_list);
378 spin_lock_init(&ret->mcg_spl);
383 static struct res_common *alloc_mtt_tr(int id, int order)
387 ret = kzalloc(sizeof *ret, GFP_KERNEL);
391 ret->com.res_id = id;
393 ret->com.state = RES_MTT_ALLOCATED;
394 atomic_set(&ret->ref_count, 0);
399 static struct res_common *alloc_mpt_tr(int id, int key)
403 ret = kzalloc(sizeof *ret, GFP_KERNEL);
407 ret->com.res_id = id;
408 ret->com.state = RES_MPT_RESERVED;
414 static struct res_common *alloc_eq_tr(int id)
418 ret = kzalloc(sizeof *ret, GFP_KERNEL);
422 ret->com.res_id = id;
423 ret->com.state = RES_EQ_RESERVED;
428 static struct res_common *alloc_cq_tr(int id)
432 ret = kzalloc(sizeof *ret, GFP_KERNEL);
436 ret->com.res_id = id;
437 ret->com.state = RES_CQ_ALLOCATED;
438 atomic_set(&ret->ref_count, 0);
443 static struct res_common *alloc_srq_tr(int id)
447 ret = kzalloc(sizeof *ret, GFP_KERNEL);
451 ret->com.res_id = id;
452 ret->com.state = RES_SRQ_ALLOCATED;
453 atomic_set(&ret->ref_count, 0);
458 static struct res_common *alloc_counter_tr(int id)
460 struct res_counter *ret;
462 ret = kzalloc(sizeof *ret, GFP_KERNEL);
466 ret->com.res_id = id;
467 ret->com.state = RES_COUNTER_ALLOCATED;
472 static struct res_common *alloc_tr(int id, enum mlx4_resource type, int slave,
475 struct res_common *ret;
479 ret = alloc_qp_tr(id);
482 ret = alloc_mpt_tr(id, extra);
485 ret = alloc_mtt_tr(id, extra);
488 ret = alloc_eq_tr(id);
491 ret = alloc_cq_tr(id);
494 ret = alloc_srq_tr(id);
497 printk(KERN_ERR "implementation missing\n");
500 ret = alloc_counter_tr(id);
512 static int add_res_range(struct mlx4_dev *dev, int slave, int base, int count,
513 enum mlx4_resource type, int extra)
517 struct mlx4_priv *priv = mlx4_priv(dev);
518 struct res_common **res_arr;
519 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
520 struct radix_tree_root *root = &tracker->res_tree[type];
522 res_arr = kzalloc(count * sizeof *res_arr, GFP_KERNEL);
526 for (i = 0; i < count; ++i) {
527 res_arr[i] = alloc_tr(base + i, type, slave, extra);
529 for (--i; i >= 0; --i)
537 spin_lock_irq(mlx4_tlock(dev));
538 for (i = 0; i < count; ++i) {
539 if (find_res(dev, base + i, type)) {
543 err = radix_tree_insert(root, base + i, res_arr[i]);
546 list_add_tail(&res_arr[i]->list,
547 &tracker->slave_list[slave].res_list[type]);
549 spin_unlock_irq(mlx4_tlock(dev));
555 for (--i; i >= base; --i)
556 radix_tree_delete(&tracker->res_tree[type], i);
558 spin_unlock_irq(mlx4_tlock(dev));
560 for (i = 0; i < count; ++i)
568 static int remove_qp_ok(struct res_qp *res)
570 if (res->com.state == RES_QP_BUSY)
572 else if (res->com.state != RES_QP_RESERVED)
578 static int remove_mtt_ok(struct res_mtt *res, int order)
580 if (res->com.state == RES_MTT_BUSY ||
581 atomic_read(&res->ref_count)) {
582 printk(KERN_DEBUG "%s-%d: state %s, ref_count %d\n",
584 mtt_states_str(res->com.state),
585 atomic_read(&res->ref_count));
587 } else if (res->com.state != RES_MTT_ALLOCATED)
589 else if (res->order != order)
595 static int remove_mpt_ok(struct res_mpt *res)
597 if (res->com.state == RES_MPT_BUSY)
599 else if (res->com.state != RES_MPT_RESERVED)
605 static int remove_eq_ok(struct res_eq *res)
607 if (res->com.state == RES_MPT_BUSY)
609 else if (res->com.state != RES_MPT_RESERVED)
615 static int remove_counter_ok(struct res_counter *res)
617 if (res->com.state == RES_COUNTER_BUSY)
619 else if (res->com.state != RES_COUNTER_ALLOCATED)
625 static int remove_cq_ok(struct res_cq *res)
627 if (res->com.state == RES_CQ_BUSY)
629 else if (res->com.state != RES_CQ_ALLOCATED)
635 static int remove_srq_ok(struct res_srq *res)
637 if (res->com.state == RES_SRQ_BUSY)
639 else if (res->com.state != RES_SRQ_ALLOCATED)
645 static int remove_ok(struct res_common *res, enum mlx4_resource type, int extra)
649 return remove_qp_ok((struct res_qp *)res);
651 return remove_cq_ok((struct res_cq *)res);
653 return remove_srq_ok((struct res_srq *)res);
655 return remove_mpt_ok((struct res_mpt *)res);
657 return remove_mtt_ok((struct res_mtt *)res, extra);
661 return remove_eq_ok((struct res_eq *)res);
663 return remove_counter_ok((struct res_counter *)res);
669 static int rem_res_range(struct mlx4_dev *dev, int slave, int base, int count,
670 enum mlx4_resource type, int extra)
674 struct mlx4_priv *priv = mlx4_priv(dev);
675 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
676 struct res_common *r;
678 spin_lock_irq(mlx4_tlock(dev));
679 for (i = base; i < base + count; ++i) {
680 r = radix_tree_lookup(&tracker->res_tree[type], i);
685 if (r->owner != slave) {
689 err = remove_ok(r, type, extra);
694 for (i = base; i < base + count; ++i) {
695 r = radix_tree_lookup(&tracker->res_tree[type], i);
696 radix_tree_delete(&tracker->res_tree[type], i);
703 spin_unlock_irq(mlx4_tlock(dev));
708 static int qp_res_start_move_to(struct mlx4_dev *dev, int slave, int qpn,
709 enum res_qp_states state, struct res_qp **qp,
712 struct mlx4_priv *priv = mlx4_priv(dev);
713 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
717 spin_lock_irq(mlx4_tlock(dev));
718 r = radix_tree_lookup(&tracker->res_tree[RES_QP], qpn);
721 else if (r->com.owner != slave)
726 mlx4_dbg(dev, "%s: failed RES_QP, 0x%x\n",
727 __func__, r->com.res_id);
731 case RES_QP_RESERVED:
732 if (r->com.state == RES_QP_MAPPED && !alloc)
735 mlx4_dbg(dev, "failed RES_QP, 0x%x\n", r->com.res_id);
740 if ((r->com.state == RES_QP_RESERVED && alloc) ||
741 r->com.state == RES_QP_HW)
744 mlx4_dbg(dev, "failed RES_QP, 0x%x\n",
752 if (r->com.state != RES_QP_MAPPED)
760 r->com.from_state = r->com.state;
761 r->com.to_state = state;
762 r->com.state = RES_QP_BUSY;
764 *qp = (struct res_qp *)r;
768 spin_unlock_irq(mlx4_tlock(dev));
773 static int mr_res_start_move_to(struct mlx4_dev *dev, int slave, int index,
774 enum res_mpt_states state, struct res_mpt **mpt)
776 struct mlx4_priv *priv = mlx4_priv(dev);
777 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
781 spin_lock_irq(mlx4_tlock(dev));
782 r = radix_tree_lookup(&tracker->res_tree[RES_MPT], index);
785 else if (r->com.owner != slave)
793 case RES_MPT_RESERVED:
794 if (r->com.state != RES_MPT_MAPPED)
799 if (r->com.state != RES_MPT_RESERVED &&
800 r->com.state != RES_MPT_HW)
805 if (r->com.state != RES_MPT_MAPPED)
813 r->com.from_state = r->com.state;
814 r->com.to_state = state;
815 r->com.state = RES_MPT_BUSY;
817 *mpt = (struct res_mpt *)r;
821 spin_unlock_irq(mlx4_tlock(dev));
826 static int eq_res_start_move_to(struct mlx4_dev *dev, int slave, int index,
827 enum res_eq_states state, struct res_eq **eq)
829 struct mlx4_priv *priv = mlx4_priv(dev);
830 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
834 spin_lock_irq(mlx4_tlock(dev));
835 r = radix_tree_lookup(&tracker->res_tree[RES_EQ], index);
838 else if (r->com.owner != slave)
846 case RES_EQ_RESERVED:
847 if (r->com.state != RES_EQ_HW)
852 if (r->com.state != RES_EQ_RESERVED)
861 r->com.from_state = r->com.state;
862 r->com.to_state = state;
863 r->com.state = RES_EQ_BUSY;
869 spin_unlock_irq(mlx4_tlock(dev));
874 static int cq_res_start_move_to(struct mlx4_dev *dev, int slave, int cqn,
875 enum res_cq_states state, struct res_cq **cq)
877 struct mlx4_priv *priv = mlx4_priv(dev);
878 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
882 spin_lock_irq(mlx4_tlock(dev));
883 r = radix_tree_lookup(&tracker->res_tree[RES_CQ], cqn);
886 else if (r->com.owner != slave)
894 case RES_CQ_ALLOCATED:
895 if (r->com.state != RES_CQ_HW)
897 else if (atomic_read(&r->ref_count))
904 if (r->com.state != RES_CQ_ALLOCATED)
915 r->com.from_state = r->com.state;
916 r->com.to_state = state;
917 r->com.state = RES_CQ_BUSY;
923 spin_unlock_irq(mlx4_tlock(dev));
928 static int srq_res_start_move_to(struct mlx4_dev *dev, int slave, int index,
929 enum res_cq_states state, struct res_srq **srq)
931 struct mlx4_priv *priv = mlx4_priv(dev);
932 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
936 spin_lock_irq(mlx4_tlock(dev));
937 r = radix_tree_lookup(&tracker->res_tree[RES_SRQ], index);
940 else if (r->com.owner != slave)
948 case RES_SRQ_ALLOCATED:
949 if (r->com.state != RES_SRQ_HW)
951 else if (atomic_read(&r->ref_count))
956 if (r->com.state != RES_SRQ_ALLOCATED)
965 r->com.from_state = r->com.state;
966 r->com.to_state = state;
967 r->com.state = RES_SRQ_BUSY;
973 spin_unlock_irq(mlx4_tlock(dev));
978 static void res_abort_move(struct mlx4_dev *dev, int slave,
979 enum mlx4_resource type, int id)
981 struct mlx4_priv *priv = mlx4_priv(dev);
982 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
983 struct res_common *r;
985 spin_lock_irq(mlx4_tlock(dev));
986 r = radix_tree_lookup(&tracker->res_tree[type], id);
987 if (r && (r->owner == slave))
988 r->state = r->from_state;
989 spin_unlock_irq(mlx4_tlock(dev));
992 static void res_end_move(struct mlx4_dev *dev, int slave,
993 enum mlx4_resource type, int id)
995 struct mlx4_priv *priv = mlx4_priv(dev);
996 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
997 struct res_common *r;
999 spin_lock_irq(mlx4_tlock(dev));
1000 r = radix_tree_lookup(&tracker->res_tree[type], id);
1001 if (r && (r->owner == slave))
1002 r->state = r->to_state;
1003 spin_unlock_irq(mlx4_tlock(dev));
1006 static int valid_reserved(struct mlx4_dev *dev, int slave, int qpn)
1008 return mlx4_is_qp_reserved(dev, qpn);
1011 static int qp_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1012 u64 in_param, u64 *out_param)
1021 case RES_OP_RESERVE:
1022 count = get_param_l(&in_param);
1023 align = get_param_h(&in_param);
1024 err = __mlx4_qp_reserve_range(dev, count, align, &base);
1028 err = add_res_range(dev, slave, base, count, RES_QP, 0);
1030 __mlx4_qp_release_range(dev, base, count);
1033 set_param_l(out_param, base);
1035 case RES_OP_MAP_ICM:
1036 qpn = get_param_l(&in_param) & 0x7fffff;
1037 if (valid_reserved(dev, slave, qpn)) {
1038 err = add_res_range(dev, slave, qpn, 1, RES_QP, 0);
1043 err = qp_res_start_move_to(dev, slave, qpn, RES_QP_MAPPED,
1048 if (!valid_reserved(dev, slave, qpn)) {
1049 err = __mlx4_qp_alloc_icm(dev, qpn);
1051 res_abort_move(dev, slave, RES_QP, qpn);
1056 res_end_move(dev, slave, RES_QP, qpn);
1066 static int mtt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1067 u64 in_param, u64 *out_param)
1073 if (op != RES_OP_RESERVE_AND_MAP)
1076 order = get_param_l(&in_param);
1077 base = __mlx4_alloc_mtt_range(dev, order);
1081 err = add_res_range(dev, slave, base, 1, RES_MTT, order);
1083 __mlx4_free_mtt_range(dev, base, order);
1085 set_param_l(out_param, base);
1090 static int mpt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1091 u64 in_param, u64 *out_param)
1096 struct res_mpt *mpt;
1099 case RES_OP_RESERVE:
1100 index = __mlx4_mr_reserve(dev);
1103 id = index & mpt_mask(dev);
1105 err = add_res_range(dev, slave, id, 1, RES_MPT, index);
1107 __mlx4_mr_release(dev, index);
1110 set_param_l(out_param, index);
1112 case RES_OP_MAP_ICM:
1113 index = get_param_l(&in_param);
1114 id = index & mpt_mask(dev);
1115 err = mr_res_start_move_to(dev, slave, id,
1116 RES_MPT_MAPPED, &mpt);
1120 err = __mlx4_mr_alloc_icm(dev, mpt->key);
1122 res_abort_move(dev, slave, RES_MPT, id);
1126 res_end_move(dev, slave, RES_MPT, id);
1132 static int cq_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1133 u64 in_param, u64 *out_param)
1139 case RES_OP_RESERVE_AND_MAP:
1140 err = __mlx4_cq_alloc_icm(dev, &cqn);
1144 err = add_res_range(dev, slave, cqn, 1, RES_CQ, 0);
1146 __mlx4_cq_free_icm(dev, cqn);
1150 set_param_l(out_param, cqn);
1160 static int srq_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1161 u64 in_param, u64 *out_param)
1167 case RES_OP_RESERVE_AND_MAP:
1168 err = __mlx4_srq_alloc_icm(dev, &srqn);
1172 err = add_res_range(dev, slave, srqn, 1, RES_SRQ, 0);
1174 __mlx4_srq_free_icm(dev, srqn);
1178 set_param_l(out_param, srqn);
1188 static int mac_add_to_slave(struct mlx4_dev *dev, int slave, u64 mac, int port)
1190 struct mlx4_priv *priv = mlx4_priv(dev);
1191 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1192 struct mac_res *res;
1194 res = kzalloc(sizeof *res, GFP_KERNEL);
1198 res->port = (u8) port;
1199 list_add_tail(&res->list,
1200 &tracker->slave_list[slave].res_list[RES_MAC]);
1204 static void mac_del_from_slave(struct mlx4_dev *dev, int slave, u64 mac,
1207 struct mlx4_priv *priv = mlx4_priv(dev);
1208 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1209 struct list_head *mac_list =
1210 &tracker->slave_list[slave].res_list[RES_MAC];
1211 struct mac_res *res, *tmp;
1213 list_for_each_entry_safe(res, tmp, mac_list, list) {
1214 if (res->mac == mac && res->port == (u8) port) {
1215 list_del(&res->list);
1222 static void rem_slave_macs(struct mlx4_dev *dev, int slave)
1224 struct mlx4_priv *priv = mlx4_priv(dev);
1225 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1226 struct list_head *mac_list =
1227 &tracker->slave_list[slave].res_list[RES_MAC];
1228 struct mac_res *res, *tmp;
1230 list_for_each_entry_safe(res, tmp, mac_list, list) {
1231 list_del(&res->list);
1232 __mlx4_unregister_mac(dev, res->port, res->mac);
1237 static int mac_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1238 u64 in_param, u64 *out_param)
1244 if (op != RES_OP_RESERVE_AND_MAP)
1247 port = get_param_l(out_param);
1250 err = __mlx4_register_mac(dev, port, mac);
1252 set_param_l(out_param, err);
1257 err = mac_add_to_slave(dev, slave, mac, port);
1259 __mlx4_unregister_mac(dev, port, mac);
1264 static int vlan_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1265 u64 in_param, u64 *out_param)
1270 int mlx4_ALLOC_RES_wrapper(struct mlx4_dev *dev, int slave,
1271 struct mlx4_vhcr *vhcr,
1272 struct mlx4_cmd_mailbox *inbox,
1273 struct mlx4_cmd_mailbox *outbox,
1274 struct mlx4_cmd_info *cmd)
1277 int alop = vhcr->op_modifier;
1279 switch (vhcr->in_modifier) {
1281 err = qp_alloc_res(dev, slave, vhcr->op_modifier, alop,
1282 vhcr->in_param, &vhcr->out_param);
1286 err = mtt_alloc_res(dev, slave, vhcr->op_modifier, alop,
1287 vhcr->in_param, &vhcr->out_param);
1291 err = mpt_alloc_res(dev, slave, vhcr->op_modifier, alop,
1292 vhcr->in_param, &vhcr->out_param);
1296 err = cq_alloc_res(dev, slave, vhcr->op_modifier, alop,
1297 vhcr->in_param, &vhcr->out_param);
1301 err = srq_alloc_res(dev, slave, vhcr->op_modifier, alop,
1302 vhcr->in_param, &vhcr->out_param);
1306 err = mac_alloc_res(dev, slave, vhcr->op_modifier, alop,
1307 vhcr->in_param, &vhcr->out_param);
1311 err = vlan_alloc_res(dev, slave, vhcr->op_modifier, alop,
1312 vhcr->in_param, &vhcr->out_param);
1323 static int qp_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1332 case RES_OP_RESERVE:
1333 base = get_param_l(&in_param) & 0x7fffff;
1334 count = get_param_h(&in_param);
1335 err = rem_res_range(dev, slave, base, count, RES_QP, 0);
1338 __mlx4_qp_release_range(dev, base, count);
1340 case RES_OP_MAP_ICM:
1341 qpn = get_param_l(&in_param) & 0x7fffff;
1342 err = qp_res_start_move_to(dev, slave, qpn, RES_QP_RESERVED,
1347 if (!valid_reserved(dev, slave, qpn))
1348 __mlx4_qp_free_icm(dev, qpn);
1350 res_end_move(dev, slave, RES_QP, qpn);
1352 if (valid_reserved(dev, slave, qpn))
1353 err = rem_res_range(dev, slave, qpn, 1, RES_QP, 0);
1362 static int mtt_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1363 u64 in_param, u64 *out_param)
1369 if (op != RES_OP_RESERVE_AND_MAP)
1372 base = get_param_l(&in_param);
1373 order = get_param_h(&in_param);
1374 err = rem_res_range(dev, slave, base, 1, RES_MTT, order);
1376 __mlx4_free_mtt_range(dev, base, order);
1380 static int mpt_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1386 struct res_mpt *mpt;
1389 case RES_OP_RESERVE:
1390 index = get_param_l(&in_param);
1391 id = index & mpt_mask(dev);
1392 err = get_res(dev, slave, id, RES_MPT, &mpt);
1396 put_res(dev, slave, id, RES_MPT);
1398 err = rem_res_range(dev, slave, id, 1, RES_MPT, 0);
1401 __mlx4_mr_release(dev, index);
1403 case RES_OP_MAP_ICM:
1404 index = get_param_l(&in_param);
1405 id = index & mpt_mask(dev);
1406 err = mr_res_start_move_to(dev, slave, id,
1407 RES_MPT_RESERVED, &mpt);
1411 __mlx4_mr_free_icm(dev, mpt->key);
1412 res_end_move(dev, slave, RES_MPT, id);
1422 static int cq_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1423 u64 in_param, u64 *out_param)
1429 case RES_OP_RESERVE_AND_MAP:
1430 cqn = get_param_l(&in_param);
1431 err = rem_res_range(dev, slave, cqn, 1, RES_CQ, 0);
1435 __mlx4_cq_free_icm(dev, cqn);
1446 static int srq_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1447 u64 in_param, u64 *out_param)
1453 case RES_OP_RESERVE_AND_MAP:
1454 srqn = get_param_l(&in_param);
1455 err = rem_res_range(dev, slave, srqn, 1, RES_SRQ, 0);
1459 __mlx4_srq_free_icm(dev, srqn);
1470 static int mac_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1471 u64 in_param, u64 *out_param)
1477 case RES_OP_RESERVE_AND_MAP:
1478 port = get_param_l(out_param);
1479 mac_del_from_slave(dev, slave, in_param, port);
1480 __mlx4_unregister_mac(dev, port, in_param);
1491 static int vlan_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,
1492 u64 in_param, u64 *out_param)
1497 int mlx4_FREE_RES_wrapper(struct mlx4_dev *dev, int slave,
1498 struct mlx4_vhcr *vhcr,
1499 struct mlx4_cmd_mailbox *inbox,
1500 struct mlx4_cmd_mailbox *outbox,
1501 struct mlx4_cmd_info *cmd)
1504 int alop = vhcr->op_modifier;
1506 switch (vhcr->in_modifier) {
1508 err = qp_free_res(dev, slave, vhcr->op_modifier, alop,
1513 err = mtt_free_res(dev, slave, vhcr->op_modifier, alop,
1514 vhcr->in_param, &vhcr->out_param);
1518 err = mpt_free_res(dev, slave, vhcr->op_modifier, alop,
1523 err = cq_free_res(dev, slave, vhcr->op_modifier, alop,
1524 vhcr->in_param, &vhcr->out_param);
1528 err = srq_free_res(dev, slave, vhcr->op_modifier, alop,
1529 vhcr->in_param, &vhcr->out_param);
1533 err = mac_free_res(dev, slave, vhcr->op_modifier, alop,
1534 vhcr->in_param, &vhcr->out_param);
1538 err = vlan_free_res(dev, slave, vhcr->op_modifier, alop,
1539 vhcr->in_param, &vhcr->out_param);
1548 /* ugly but other choices are uglier */
1549 static int mr_phys_mpt(struct mlx4_mpt_entry *mpt)
1551 return (be32_to_cpu(mpt->flags) >> 9) & 1;
1554 static int mr_get_mtt_addr(struct mlx4_mpt_entry *mpt)
1556 return (int)be64_to_cpu(mpt->mtt_addr) & 0xfffffff8;
1559 static int mr_get_mtt_size(struct mlx4_mpt_entry *mpt)
1561 return be32_to_cpu(mpt->mtt_sz);
1564 static int mr_get_pdn(struct mlx4_mpt_entry *mpt)
1566 return be32_to_cpu(mpt->pd_flags) & 0xffffff;
1569 static int qp_get_mtt_addr(struct mlx4_qp_context *qpc)
1571 return be32_to_cpu(qpc->mtt_base_addr_l) & 0xfffffff8;
1574 static int srq_get_mtt_addr(struct mlx4_srq_context *srqc)
1576 return be32_to_cpu(srqc->mtt_base_addr_l) & 0xfffffff8;
1579 static int qp_get_mtt_size(struct mlx4_qp_context *qpc)
1581 int page_shift = (qpc->log_page_size & 0x3f) + 12;
1582 int log_sq_size = (qpc->sq_size_stride >> 3) & 0xf;
1583 int log_sq_sride = qpc->sq_size_stride & 7;
1584 int log_rq_size = (qpc->rq_size_stride >> 3) & 0xf;
1585 int log_rq_stride = qpc->rq_size_stride & 7;
1586 int srq = (be32_to_cpu(qpc->srqn) >> 24) & 1;
1587 int rss = (be32_to_cpu(qpc->flags) >> 13) & 1;
1588 int xrc = (be32_to_cpu(qpc->local_qpn) >> 23) & 1;
1593 int page_offset = (be32_to_cpu(qpc->params2) >> 6) & 0x3f;
1595 sq_size = 1 << (log_sq_size + log_sq_sride + 4);
1596 rq_size = (srq|rss|xrc) ? 0 : (1 << (log_rq_size + log_rq_stride + 4));
1597 total_mem = sq_size + rq_size;
1599 roundup_pow_of_two((total_mem + (page_offset << 6)) >>
1605 static int qp_get_pdn(struct mlx4_qp_context *qpc)
1607 return be32_to_cpu(qpc->pd) & 0xffffff;
1610 static int pdn2slave(int pdn)
1612 return (pdn >> NOT_MASKED_PD_BITS) - 1;
1615 static int check_mtt_range(struct mlx4_dev *dev, int slave, int start,
1616 int size, struct res_mtt *mtt)
1618 int res_start = mtt->com.res_id;
1619 int res_size = (1 << mtt->order);
1621 if (start < res_start || start + size > res_start + res_size)
1626 int mlx4_SW2HW_MPT_wrapper(struct mlx4_dev *dev, int slave,
1627 struct mlx4_vhcr *vhcr,
1628 struct mlx4_cmd_mailbox *inbox,
1629 struct mlx4_cmd_mailbox *outbox,
1630 struct mlx4_cmd_info *cmd)
1633 int index = vhcr->in_modifier;
1634 struct res_mtt *mtt;
1635 struct res_mpt *mpt;
1636 int mtt_base = mr_get_mtt_addr(inbox->buf) / dev->caps.mtt_entry_sz;
1640 id = index & mpt_mask(dev);
1641 err = mr_res_start_move_to(dev, slave, id, RES_MPT_HW, &mpt);
1645 phys = mr_phys_mpt(inbox->buf);
1647 err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
1651 err = check_mtt_range(dev, slave, mtt_base,
1652 mr_get_mtt_size(inbox->buf), mtt);
1659 if (pdn2slave(mr_get_pdn(inbox->buf)) != slave) {
1664 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1669 atomic_inc(&mtt->ref_count);
1670 put_res(dev, slave, mtt->com.res_id, RES_MTT);
1673 res_end_move(dev, slave, RES_MPT, id);
1678 put_res(dev, slave, mtt->com.res_id, RES_MTT);
1680 res_abort_move(dev, slave, RES_MPT, id);
1685 int mlx4_HW2SW_MPT_wrapper(struct mlx4_dev *dev, int slave,
1686 struct mlx4_vhcr *vhcr,
1687 struct mlx4_cmd_mailbox *inbox,
1688 struct mlx4_cmd_mailbox *outbox,
1689 struct mlx4_cmd_info *cmd)
1692 int index = vhcr->in_modifier;
1693 struct res_mpt *mpt;
1696 id = index & mpt_mask(dev);
1697 err = mr_res_start_move_to(dev, slave, id, RES_MPT_MAPPED, &mpt);
1701 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1706 atomic_dec(&mpt->mtt->ref_count);
1708 res_end_move(dev, slave, RES_MPT, id);
1712 res_abort_move(dev, slave, RES_MPT, id);
1717 int mlx4_QUERY_MPT_wrapper(struct mlx4_dev *dev, int slave,
1718 struct mlx4_vhcr *vhcr,
1719 struct mlx4_cmd_mailbox *inbox,
1720 struct mlx4_cmd_mailbox *outbox,
1721 struct mlx4_cmd_info *cmd)
1724 int index = vhcr->in_modifier;
1725 struct res_mpt *mpt;
1728 id = index & mpt_mask(dev);
1729 err = get_res(dev, slave, id, RES_MPT, &mpt);
1733 if (mpt->com.from_state != RES_MPT_HW) {
1738 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1741 put_res(dev, slave, id, RES_MPT);
1745 static int qp_get_rcqn(struct mlx4_qp_context *qpc)
1747 return be32_to_cpu(qpc->cqn_recv) & 0xffffff;
1750 static int qp_get_scqn(struct mlx4_qp_context *qpc)
1752 return be32_to_cpu(qpc->cqn_send) & 0xffffff;
1755 static u32 qp_get_srqn(struct mlx4_qp_context *qpc)
1757 return be32_to_cpu(qpc->srqn) & 0x1ffffff;
1760 int mlx4_RST2INIT_QP_wrapper(struct mlx4_dev *dev, int slave,
1761 struct mlx4_vhcr *vhcr,
1762 struct mlx4_cmd_mailbox *inbox,
1763 struct mlx4_cmd_mailbox *outbox,
1764 struct mlx4_cmd_info *cmd)
1767 int qpn = vhcr->in_modifier & 0x7fffff;
1768 struct res_mtt *mtt;
1770 struct mlx4_qp_context *qpc = inbox->buf + 8;
1771 int mtt_base = qp_get_mtt_addr(qpc) / dev->caps.mtt_entry_sz;
1772 int mtt_size = qp_get_mtt_size(qpc);
1775 int rcqn = qp_get_rcqn(qpc);
1776 int scqn = qp_get_scqn(qpc);
1777 u32 srqn = qp_get_srqn(qpc) & 0xffffff;
1778 int use_srq = (qp_get_srqn(qpc) >> 24) & 1;
1779 struct res_srq *srq;
1780 int local_qpn = be32_to_cpu(qpc->local_qpn) & 0xffffff;
1782 err = qp_res_start_move_to(dev, slave, qpn, RES_QP_HW, &qp, 0);
1785 qp->local_qpn = local_qpn;
1787 err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
1791 err = check_mtt_range(dev, slave, mtt_base, mtt_size, mtt);
1795 if (pdn2slave(qp_get_pdn(qpc)) != slave) {
1800 err = get_res(dev, slave, rcqn, RES_CQ, &rcq);
1805 err = get_res(dev, slave, scqn, RES_CQ, &scq);
1812 err = get_res(dev, slave, srqn, RES_SRQ, &srq);
1817 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1820 atomic_inc(&mtt->ref_count);
1822 atomic_inc(&rcq->ref_count);
1824 atomic_inc(&scq->ref_count);
1828 put_res(dev, slave, scqn, RES_CQ);
1831 atomic_inc(&srq->ref_count);
1832 put_res(dev, slave, srqn, RES_SRQ);
1835 put_res(dev, slave, rcqn, RES_CQ);
1836 put_res(dev, slave, mtt_base, RES_MTT);
1837 res_end_move(dev, slave, RES_QP, qpn);
1843 put_res(dev, slave, srqn, RES_SRQ);
1846 put_res(dev, slave, scqn, RES_CQ);
1848 put_res(dev, slave, rcqn, RES_CQ);
1850 put_res(dev, slave, mtt_base, RES_MTT);
1852 res_abort_move(dev, slave, RES_QP, qpn);
1857 static int eq_get_mtt_addr(struct mlx4_eq_context *eqc)
1859 return be32_to_cpu(eqc->mtt_base_addr_l) & 0xfffffff8;
1862 static int eq_get_mtt_size(struct mlx4_eq_context *eqc)
1864 int log_eq_size = eqc->log_eq_size & 0x1f;
1865 int page_shift = (eqc->log_page_size & 0x3f) + 12;
1867 if (log_eq_size + 5 < page_shift)
1870 return 1 << (log_eq_size + 5 - page_shift);
1873 static int cq_get_mtt_addr(struct mlx4_cq_context *cqc)
1875 return be32_to_cpu(cqc->mtt_base_addr_l) & 0xfffffff8;
1878 static int cq_get_mtt_size(struct mlx4_cq_context *cqc)
1880 int log_cq_size = (be32_to_cpu(cqc->logsize_usrpage) >> 24) & 0x1f;
1881 int page_shift = (cqc->log_page_size & 0x3f) + 12;
1883 if (log_cq_size + 5 < page_shift)
1886 return 1 << (log_cq_size + 5 - page_shift);
1889 int mlx4_SW2HW_EQ_wrapper(struct mlx4_dev *dev, int slave,
1890 struct mlx4_vhcr *vhcr,
1891 struct mlx4_cmd_mailbox *inbox,
1892 struct mlx4_cmd_mailbox *outbox,
1893 struct mlx4_cmd_info *cmd)
1896 int eqn = vhcr->in_modifier;
1897 int res_id = (slave << 8) | eqn;
1898 struct mlx4_eq_context *eqc = inbox->buf;
1899 int mtt_base = eq_get_mtt_addr(eqc) / dev->caps.mtt_entry_sz;
1900 int mtt_size = eq_get_mtt_size(eqc);
1902 struct res_mtt *mtt;
1904 err = add_res_range(dev, slave, res_id, 1, RES_EQ, 0);
1907 err = eq_res_start_move_to(dev, slave, res_id, RES_EQ_HW, &eq);
1911 err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
1915 err = check_mtt_range(dev, slave, mtt_base, mtt_size, mtt);
1919 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
1923 atomic_inc(&mtt->ref_count);
1925 put_res(dev, slave, mtt->com.res_id, RES_MTT);
1926 res_end_move(dev, slave, RES_EQ, res_id);
1930 put_res(dev, slave, mtt->com.res_id, RES_MTT);
1932 res_abort_move(dev, slave, RES_EQ, res_id);
1934 rem_res_range(dev, slave, res_id, 1, RES_EQ, 0);
1938 static int get_containing_mtt(struct mlx4_dev *dev, int slave, int start,
1939 int len, struct res_mtt **res)
1941 struct mlx4_priv *priv = mlx4_priv(dev);
1942 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
1943 struct res_mtt *mtt;
1946 spin_lock_irq(mlx4_tlock(dev));
1947 list_for_each_entry(mtt, &tracker->slave_list[slave].res_list[RES_MTT],
1949 if (!check_mtt_range(dev, slave, start, len, mtt)) {
1951 mtt->com.from_state = mtt->com.state;
1952 mtt->com.state = RES_MTT_BUSY;
1957 spin_unlock_irq(mlx4_tlock(dev));
1962 int mlx4_WRITE_MTT_wrapper(struct mlx4_dev *dev, int slave,
1963 struct mlx4_vhcr *vhcr,
1964 struct mlx4_cmd_mailbox *inbox,
1965 struct mlx4_cmd_mailbox *outbox,
1966 struct mlx4_cmd_info *cmd)
1968 struct mlx4_mtt mtt;
1969 __be64 *page_list = inbox->buf;
1970 u64 *pg_list = (u64 *)page_list;
1972 struct res_mtt *rmtt = NULL;
1973 int start = be64_to_cpu(page_list[0]);
1974 int npages = vhcr->in_modifier;
1977 err = get_containing_mtt(dev, slave, start, npages, &rmtt);
1981 /* Call the SW implementation of write_mtt:
1982 * - Prepare a dummy mtt struct
1983 * - Translate inbox contents to simple addresses in host endianess */
1984 mtt.offset = 0; /* TBD this is broken but I don't handle it since
1985 we don't really use it */
1988 for (i = 0; i < npages; ++i)
1989 pg_list[i + 2] = (be64_to_cpu(page_list[i + 2]) & ~1ULL);
1991 err = __mlx4_write_mtt(dev, &mtt, be64_to_cpu(page_list[0]), npages,
1992 ((u64 *)page_list + 2));
1995 put_res(dev, slave, rmtt->com.res_id, RES_MTT);
2000 int mlx4_HW2SW_EQ_wrapper(struct mlx4_dev *dev, int slave,
2001 struct mlx4_vhcr *vhcr,
2002 struct mlx4_cmd_mailbox *inbox,
2003 struct mlx4_cmd_mailbox *outbox,
2004 struct mlx4_cmd_info *cmd)
2006 int eqn = vhcr->in_modifier;
2007 int res_id = eqn | (slave << 8);
2011 err = eq_res_start_move_to(dev, slave, res_id, RES_EQ_RESERVED, &eq);
2015 err = get_res(dev, slave, eq->mtt->com.res_id, RES_MTT, NULL);
2019 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2023 atomic_dec(&eq->mtt->ref_count);
2024 put_res(dev, slave, eq->mtt->com.res_id, RES_MTT);
2025 res_end_move(dev, slave, RES_EQ, res_id);
2026 rem_res_range(dev, slave, res_id, 1, RES_EQ, 0);
2031 put_res(dev, slave, eq->mtt->com.res_id, RES_MTT);
2033 res_abort_move(dev, slave, RES_EQ, res_id);
2038 int mlx4_GEN_EQE(struct mlx4_dev *dev, int slave, struct mlx4_eqe *eqe)
2040 struct mlx4_priv *priv = mlx4_priv(dev);
2041 struct mlx4_slave_event_eq_info *event_eq;
2042 struct mlx4_cmd_mailbox *mailbox;
2043 u32 in_modifier = 0;
2048 if (!priv->mfunc.master.slave_state)
2051 event_eq = &priv->mfunc.master.slave_state[slave].event_eq;
2053 /* Create the event only if the slave is registered */
2054 if ((event_eq->event_type & (1 << eqe->type)) == 0)
2057 mutex_lock(&priv->mfunc.master.gen_eqe_mutex[slave]);
2058 res_id = (slave << 8) | event_eq->eqn;
2059 err = get_res(dev, slave, res_id, RES_EQ, &req);
2063 if (req->com.from_state != RES_EQ_HW) {
2068 mailbox = mlx4_alloc_cmd_mailbox(dev);
2069 if (IS_ERR(mailbox)) {
2070 err = PTR_ERR(mailbox);
2074 if (eqe->type == MLX4_EVENT_TYPE_CMD) {
2076 eqe->event.cmd.token = cpu_to_be16(event_eq->token);
2079 memcpy(mailbox->buf, (u8 *) eqe, 28);
2081 in_modifier = (slave & 0xff) | ((event_eq->eqn & 0xff) << 16);
2083 err = mlx4_cmd(dev, mailbox->dma, in_modifier, 0,
2084 MLX4_CMD_GEN_EQE, MLX4_CMD_TIME_CLASS_B,
2087 put_res(dev, slave, res_id, RES_EQ);
2088 mutex_unlock(&priv->mfunc.master.gen_eqe_mutex[slave]);
2089 mlx4_free_cmd_mailbox(dev, mailbox);
2093 put_res(dev, slave, res_id, RES_EQ);
2096 mutex_unlock(&priv->mfunc.master.gen_eqe_mutex[slave]);
2100 int mlx4_QUERY_EQ_wrapper(struct mlx4_dev *dev, int slave,
2101 struct mlx4_vhcr *vhcr,
2102 struct mlx4_cmd_mailbox *inbox,
2103 struct mlx4_cmd_mailbox *outbox,
2104 struct mlx4_cmd_info *cmd)
2106 int eqn = vhcr->in_modifier;
2107 int res_id = eqn | (slave << 8);
2111 err = get_res(dev, slave, res_id, RES_EQ, &eq);
2115 if (eq->com.from_state != RES_EQ_HW) {
2120 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2123 put_res(dev, slave, res_id, RES_EQ);
2127 int mlx4_SW2HW_CQ_wrapper(struct mlx4_dev *dev, int slave,
2128 struct mlx4_vhcr *vhcr,
2129 struct mlx4_cmd_mailbox *inbox,
2130 struct mlx4_cmd_mailbox *outbox,
2131 struct mlx4_cmd_info *cmd)
2134 int cqn = vhcr->in_modifier;
2135 struct mlx4_cq_context *cqc = inbox->buf;
2136 int mtt_base = cq_get_mtt_addr(cqc) / dev->caps.mtt_entry_sz;
2138 struct res_mtt *mtt;
2140 err = cq_res_start_move_to(dev, slave, cqn, RES_CQ_HW, &cq);
2143 err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
2146 err = check_mtt_range(dev, slave, mtt_base, cq_get_mtt_size(cqc), mtt);
2149 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2152 atomic_inc(&mtt->ref_count);
2154 put_res(dev, slave, mtt->com.res_id, RES_MTT);
2155 res_end_move(dev, slave, RES_CQ, cqn);
2159 put_res(dev, slave, mtt->com.res_id, RES_MTT);
2161 res_abort_move(dev, slave, RES_CQ, cqn);
2165 int mlx4_HW2SW_CQ_wrapper(struct mlx4_dev *dev, int slave,
2166 struct mlx4_vhcr *vhcr,
2167 struct mlx4_cmd_mailbox *inbox,
2168 struct mlx4_cmd_mailbox *outbox,
2169 struct mlx4_cmd_info *cmd)
2172 int cqn = vhcr->in_modifier;
2175 err = cq_res_start_move_to(dev, slave, cqn, RES_CQ_ALLOCATED, &cq);
2178 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2181 atomic_dec(&cq->mtt->ref_count);
2182 res_end_move(dev, slave, RES_CQ, cqn);
2186 res_abort_move(dev, slave, RES_CQ, cqn);
2190 int mlx4_QUERY_CQ_wrapper(struct mlx4_dev *dev, int slave,
2191 struct mlx4_vhcr *vhcr,
2192 struct mlx4_cmd_mailbox *inbox,
2193 struct mlx4_cmd_mailbox *outbox,
2194 struct mlx4_cmd_info *cmd)
2196 int cqn = vhcr->in_modifier;
2200 err = get_res(dev, slave, cqn, RES_CQ, &cq);
2204 if (cq->com.from_state != RES_CQ_HW)
2207 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2209 put_res(dev, slave, cqn, RES_CQ);
2214 static int handle_resize(struct mlx4_dev *dev, int slave,
2215 struct mlx4_vhcr *vhcr,
2216 struct mlx4_cmd_mailbox *inbox,
2217 struct mlx4_cmd_mailbox *outbox,
2218 struct mlx4_cmd_info *cmd,
2222 struct res_mtt *orig_mtt;
2223 struct res_mtt *mtt;
2224 struct mlx4_cq_context *cqc = inbox->buf;
2225 int mtt_base = cq_get_mtt_addr(cqc) / dev->caps.mtt_entry_sz;
2227 err = get_res(dev, slave, cq->mtt->com.res_id, RES_MTT, &orig_mtt);
2231 if (orig_mtt != cq->mtt) {
2236 err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
2240 err = check_mtt_range(dev, slave, mtt_base, cq_get_mtt_size(cqc), mtt);
2243 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2246 atomic_dec(&orig_mtt->ref_count);
2247 put_res(dev, slave, orig_mtt->com.res_id, RES_MTT);
2248 atomic_inc(&mtt->ref_count);
2250 put_res(dev, slave, mtt->com.res_id, RES_MTT);
2254 put_res(dev, slave, mtt->com.res_id, RES_MTT);
2256 put_res(dev, slave, orig_mtt->com.res_id, RES_MTT);
2262 int mlx4_MODIFY_CQ_wrapper(struct mlx4_dev *dev, int slave,
2263 struct mlx4_vhcr *vhcr,
2264 struct mlx4_cmd_mailbox *inbox,
2265 struct mlx4_cmd_mailbox *outbox,
2266 struct mlx4_cmd_info *cmd)
2268 int cqn = vhcr->in_modifier;
2272 err = get_res(dev, slave, cqn, RES_CQ, &cq);
2276 if (cq->com.from_state != RES_CQ_HW)
2279 if (vhcr->op_modifier == 0) {
2280 err = handle_resize(dev, slave, vhcr, inbox, outbox, cmd, cq);
2285 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2287 put_res(dev, slave, cqn, RES_CQ);
2292 static int srq_get_pdn(struct mlx4_srq_context *srqc)
2294 return be32_to_cpu(srqc->pd) & 0xffffff;
2297 static int srq_get_mtt_size(struct mlx4_srq_context *srqc)
2299 int log_srq_size = (be32_to_cpu(srqc->state_logsize_srqn) >> 24) & 0xf;
2300 int log_rq_stride = srqc->logstride & 7;
2301 int page_shift = (srqc->log_page_size & 0x3f) + 12;
2303 if (log_srq_size + log_rq_stride + 4 < page_shift)
2306 return 1 << (log_srq_size + log_rq_stride + 4 - page_shift);
2309 int mlx4_SW2HW_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2310 struct mlx4_vhcr *vhcr,
2311 struct mlx4_cmd_mailbox *inbox,
2312 struct mlx4_cmd_mailbox *outbox,
2313 struct mlx4_cmd_info *cmd)
2316 int srqn = vhcr->in_modifier;
2317 struct res_mtt *mtt;
2318 struct res_srq *srq;
2319 struct mlx4_srq_context *srqc = inbox->buf;
2320 int mtt_base = srq_get_mtt_addr(srqc) / dev->caps.mtt_entry_sz;
2322 if (srqn != (be32_to_cpu(srqc->state_logsize_srqn) & 0xffffff))
2325 err = srq_res_start_move_to(dev, slave, srqn, RES_SRQ_HW, &srq);
2328 err = get_res(dev, slave, mtt_base, RES_MTT, &mtt);
2331 err = check_mtt_range(dev, slave, mtt_base, srq_get_mtt_size(srqc),
2336 if (pdn2slave(srq_get_pdn(srqc)) != slave) {
2341 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2345 atomic_inc(&mtt->ref_count);
2347 put_res(dev, slave, mtt->com.res_id, RES_MTT);
2348 res_end_move(dev, slave, RES_SRQ, srqn);
2352 put_res(dev, slave, mtt->com.res_id, RES_MTT);
2354 res_abort_move(dev, slave, RES_SRQ, srqn);
2359 int mlx4_HW2SW_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2360 struct mlx4_vhcr *vhcr,
2361 struct mlx4_cmd_mailbox *inbox,
2362 struct mlx4_cmd_mailbox *outbox,
2363 struct mlx4_cmd_info *cmd)
2366 int srqn = vhcr->in_modifier;
2367 struct res_srq *srq;
2369 err = srq_res_start_move_to(dev, slave, srqn, RES_SRQ_ALLOCATED, &srq);
2372 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2375 atomic_dec(&srq->mtt->ref_count);
2377 atomic_dec(&srq->cq->ref_count);
2378 res_end_move(dev, slave, RES_SRQ, srqn);
2383 res_abort_move(dev, slave, RES_SRQ, srqn);
2388 int mlx4_QUERY_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2389 struct mlx4_vhcr *vhcr,
2390 struct mlx4_cmd_mailbox *inbox,
2391 struct mlx4_cmd_mailbox *outbox,
2392 struct mlx4_cmd_info *cmd)
2395 int srqn = vhcr->in_modifier;
2396 struct res_srq *srq;
2398 err = get_res(dev, slave, srqn, RES_SRQ, &srq);
2401 if (srq->com.from_state != RES_SRQ_HW) {
2405 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2407 put_res(dev, slave, srqn, RES_SRQ);
2411 int mlx4_ARM_SRQ_wrapper(struct mlx4_dev *dev, int slave,
2412 struct mlx4_vhcr *vhcr,
2413 struct mlx4_cmd_mailbox *inbox,
2414 struct mlx4_cmd_mailbox *outbox,
2415 struct mlx4_cmd_info *cmd)
2418 int srqn = vhcr->in_modifier;
2419 struct res_srq *srq;
2421 err = get_res(dev, slave, srqn, RES_SRQ, &srq);
2425 if (srq->com.from_state != RES_SRQ_HW) {
2430 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2432 put_res(dev, slave, srqn, RES_SRQ);
2436 int mlx4_GEN_QP_wrapper(struct mlx4_dev *dev, int slave,
2437 struct mlx4_vhcr *vhcr,
2438 struct mlx4_cmd_mailbox *inbox,
2439 struct mlx4_cmd_mailbox *outbox,
2440 struct mlx4_cmd_info *cmd)
2443 int qpn = vhcr->in_modifier & 0x7fffff;
2446 err = get_res(dev, slave, qpn, RES_QP, &qp);
2449 if (qp->com.from_state != RES_QP_HW) {
2454 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2456 put_res(dev, slave, qpn, RES_QP);
2460 int mlx4_INIT2RTR_QP_wrapper(struct mlx4_dev *dev, int slave,
2461 struct mlx4_vhcr *vhcr,
2462 struct mlx4_cmd_mailbox *inbox,
2463 struct mlx4_cmd_mailbox *outbox,
2464 struct mlx4_cmd_info *cmd)
2466 struct mlx4_qp_context *qpc = inbox->buf + 8;
2468 update_ud_gid(dev, qpc, (u8)slave);
2470 return mlx4_GEN_QP_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2473 int mlx4_2RST_QP_wrapper(struct mlx4_dev *dev, int slave,
2474 struct mlx4_vhcr *vhcr,
2475 struct mlx4_cmd_mailbox *inbox,
2476 struct mlx4_cmd_mailbox *outbox,
2477 struct mlx4_cmd_info *cmd)
2480 int qpn = vhcr->in_modifier & 0x7fffff;
2483 err = qp_res_start_move_to(dev, slave, qpn, RES_QP_MAPPED, &qp, 0);
2486 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2490 atomic_dec(&qp->mtt->ref_count);
2491 atomic_dec(&qp->rcq->ref_count);
2492 atomic_dec(&qp->scq->ref_count);
2494 atomic_dec(&qp->srq->ref_count);
2495 res_end_move(dev, slave, RES_QP, qpn);
2499 res_abort_move(dev, slave, RES_QP, qpn);
2504 static struct res_gid *find_gid(struct mlx4_dev *dev, int slave,
2505 struct res_qp *rqp, u8 *gid)
2507 struct res_gid *res;
2509 list_for_each_entry(res, &rqp->mcg_list, list) {
2510 if (!memcmp(res->gid, gid, 16))
2516 static int add_mcg_res(struct mlx4_dev *dev, int slave, struct res_qp *rqp,
2517 u8 *gid, enum mlx4_protocol prot)
2519 struct res_gid *res;
2522 res = kzalloc(sizeof *res, GFP_KERNEL);
2526 spin_lock_irq(&rqp->mcg_spl);
2527 if (find_gid(dev, slave, rqp, gid)) {
2531 memcpy(res->gid, gid, 16);
2533 list_add_tail(&res->list, &rqp->mcg_list);
2536 spin_unlock_irq(&rqp->mcg_spl);
2541 static int rem_mcg_res(struct mlx4_dev *dev, int slave, struct res_qp *rqp,
2542 u8 *gid, enum mlx4_protocol prot)
2544 struct res_gid *res;
2547 spin_lock_irq(&rqp->mcg_spl);
2548 res = find_gid(dev, slave, rqp, gid);
2549 if (!res || res->prot != prot)
2552 list_del(&res->list);
2556 spin_unlock_irq(&rqp->mcg_spl);
2561 int mlx4_QP_ATTACH_wrapper(struct mlx4_dev *dev, int slave,
2562 struct mlx4_vhcr *vhcr,
2563 struct mlx4_cmd_mailbox *inbox,
2564 struct mlx4_cmd_mailbox *outbox,
2565 struct mlx4_cmd_info *cmd)
2567 struct mlx4_qp qp; /* dummy for calling attach/detach */
2568 u8 *gid = inbox->buf;
2569 enum mlx4_protocol prot = (vhcr->in_modifier >> 28) & 0x7;
2573 int attach = vhcr->op_modifier;
2574 int block_loopback = vhcr->in_modifier >> 31;
2575 u8 steer_type_mask = 2;
2576 enum mlx4_steer_type type = gid[7] & steer_type_mask;
2578 qpn = vhcr->in_modifier & 0xffffff;
2579 err = get_res(dev, slave, qpn, RES_QP, &rqp);
2585 err = add_mcg_res(dev, slave, rqp, gid, prot);
2589 err = mlx4_qp_attach_common(dev, &qp, gid,
2590 block_loopback, prot, type);
2594 err = rem_mcg_res(dev, slave, rqp, gid, prot);
2597 err = mlx4_qp_detach_common(dev, &qp, gid, prot, type);
2600 put_res(dev, slave, qpn, RES_QP);
2604 /* ignore error return below, already in error */
2605 err1 = rem_mcg_res(dev, slave, rqp, gid, prot);
2607 put_res(dev, slave, qpn, RES_QP);
2613 BUSY_MAX_RETRIES = 10
2616 int mlx4_QUERY_IF_STAT_wrapper(struct mlx4_dev *dev, int slave,
2617 struct mlx4_vhcr *vhcr,
2618 struct mlx4_cmd_mailbox *inbox,
2619 struct mlx4_cmd_mailbox *outbox,
2620 struct mlx4_cmd_info *cmd)
2623 int index = vhcr->in_modifier & 0xffff;
2625 err = get_res(dev, slave, index, RES_COUNTER, NULL);
2629 err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
2630 put_res(dev, slave, index, RES_COUNTER);
2634 static void detach_qp(struct mlx4_dev *dev, int slave, struct res_qp *rqp)
2636 struct res_gid *rgid;
2637 struct res_gid *tmp;
2639 struct mlx4_qp qp; /* dummy for calling attach/detach */
2641 list_for_each_entry_safe(rgid, tmp, &rqp->mcg_list, list) {
2642 qp.qpn = rqp->local_qpn;
2643 err = mlx4_qp_detach_common(dev, &qp, rgid->gid, rgid->prot,
2645 list_del(&rgid->list);
2650 static int _move_all_busy(struct mlx4_dev *dev, int slave,
2651 enum mlx4_resource type, int print)
2653 struct mlx4_priv *priv = mlx4_priv(dev);
2654 struct mlx4_resource_tracker *tracker =
2655 &priv->mfunc.master.res_tracker;
2656 struct list_head *rlist = &tracker->slave_list[slave].res_list[type];
2657 struct res_common *r;
2658 struct res_common *tmp;
2662 spin_lock_irq(mlx4_tlock(dev));
2663 list_for_each_entry_safe(r, tmp, rlist, list) {
2664 if (r->owner == slave) {
2666 if (r->state == RES_ANY_BUSY) {
2669 "%s id 0x%x is busy\n",
2674 r->from_state = r->state;
2675 r->state = RES_ANY_BUSY;
2681 spin_unlock_irq(mlx4_tlock(dev));
2686 static int move_all_busy(struct mlx4_dev *dev, int slave,
2687 enum mlx4_resource type)
2689 unsigned long begin;
2694 busy = _move_all_busy(dev, slave, type, 0);
2695 if (time_after(jiffies, begin + 5 * HZ))
2702 busy = _move_all_busy(dev, slave, type, 1);
2706 static void rem_slave_qps(struct mlx4_dev *dev, int slave)
2708 struct mlx4_priv *priv = mlx4_priv(dev);
2709 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
2710 struct list_head *qp_list =
2711 &tracker->slave_list[slave].res_list[RES_QP];
2719 err = move_all_busy(dev, slave, RES_QP);
2721 mlx4_warn(dev, "rem_slave_qps: Could not move all qps to busy"
2722 "for slave %d\n", slave);
2724 spin_lock_irq(mlx4_tlock(dev));
2725 list_for_each_entry_safe(qp, tmp, qp_list, com.list) {
2726 spin_unlock_irq(mlx4_tlock(dev));
2727 if (qp->com.owner == slave) {
2728 qpn = qp->com.res_id;
2729 detach_qp(dev, slave, qp);
2730 state = qp->com.from_state;
2731 while (state != 0) {
2733 case RES_QP_RESERVED:
2734 spin_lock_irq(mlx4_tlock(dev));
2735 radix_tree_delete(&tracker->res_tree[RES_QP],
2737 list_del(&qp->com.list);
2738 spin_unlock_irq(mlx4_tlock(dev));
2743 if (!valid_reserved(dev, slave, qpn))
2744 __mlx4_qp_free_icm(dev, qpn);
2745 state = RES_QP_RESERVED;
2749 err = mlx4_cmd(dev, in_param,
2752 MLX4_CMD_TIME_CLASS_A,
2755 mlx4_dbg(dev, "rem_slave_qps: failed"
2756 " to move slave %d qpn %d to"
2759 atomic_dec(&qp->rcq->ref_count);
2760 atomic_dec(&qp->scq->ref_count);
2761 atomic_dec(&qp->mtt->ref_count);
2763 atomic_dec(&qp->srq->ref_count);
2764 state = RES_QP_MAPPED;
2771 spin_lock_irq(mlx4_tlock(dev));
2773 spin_unlock_irq(mlx4_tlock(dev));
2776 static void rem_slave_srqs(struct mlx4_dev *dev, int slave)
2778 struct mlx4_priv *priv = mlx4_priv(dev);
2779 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
2780 struct list_head *srq_list =
2781 &tracker->slave_list[slave].res_list[RES_SRQ];
2782 struct res_srq *srq;
2783 struct res_srq *tmp;
2790 err = move_all_busy(dev, slave, RES_SRQ);
2792 mlx4_warn(dev, "rem_slave_srqs: Could not move all srqs to "
2793 "busy for slave %d\n", slave);
2795 spin_lock_irq(mlx4_tlock(dev));
2796 list_for_each_entry_safe(srq, tmp, srq_list, com.list) {
2797 spin_unlock_irq(mlx4_tlock(dev));
2798 if (srq->com.owner == slave) {
2799 srqn = srq->com.res_id;
2800 state = srq->com.from_state;
2801 while (state != 0) {
2803 case RES_SRQ_ALLOCATED:
2804 __mlx4_srq_free_icm(dev, srqn);
2805 spin_lock_irq(mlx4_tlock(dev));
2806 radix_tree_delete(&tracker->res_tree[RES_SRQ],
2808 list_del(&srq->com.list);
2809 spin_unlock_irq(mlx4_tlock(dev));
2816 err = mlx4_cmd(dev, in_param, srqn, 1,
2818 MLX4_CMD_TIME_CLASS_A,
2821 mlx4_dbg(dev, "rem_slave_srqs: failed"
2822 " to move slave %d srq %d to"
2826 atomic_dec(&srq->mtt->ref_count);
2828 atomic_dec(&srq->cq->ref_count);
2829 state = RES_SRQ_ALLOCATED;
2837 spin_lock_irq(mlx4_tlock(dev));
2839 spin_unlock_irq(mlx4_tlock(dev));
2842 static void rem_slave_cqs(struct mlx4_dev *dev, int slave)
2844 struct mlx4_priv *priv = mlx4_priv(dev);
2845 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
2846 struct list_head *cq_list =
2847 &tracker->slave_list[slave].res_list[RES_CQ];
2856 err = move_all_busy(dev, slave, RES_CQ);
2858 mlx4_warn(dev, "rem_slave_cqs: Could not move all cqs to "
2859 "busy for slave %d\n", slave);
2861 spin_lock_irq(mlx4_tlock(dev));
2862 list_for_each_entry_safe(cq, tmp, cq_list, com.list) {
2863 spin_unlock_irq(mlx4_tlock(dev));
2864 if (cq->com.owner == slave && !atomic_read(&cq->ref_count)) {
2865 cqn = cq->com.res_id;
2866 state = cq->com.from_state;
2867 while (state != 0) {
2869 case RES_CQ_ALLOCATED:
2870 __mlx4_cq_free_icm(dev, cqn);
2871 spin_lock_irq(mlx4_tlock(dev));
2872 radix_tree_delete(&tracker->res_tree[RES_CQ],
2874 list_del(&cq->com.list);
2875 spin_unlock_irq(mlx4_tlock(dev));
2882 err = mlx4_cmd(dev, in_param, cqn, 1,
2884 MLX4_CMD_TIME_CLASS_A,
2887 mlx4_dbg(dev, "rem_slave_cqs: failed"
2888 " to move slave %d cq %d to"
2891 atomic_dec(&cq->mtt->ref_count);
2892 state = RES_CQ_ALLOCATED;
2900 spin_lock_irq(mlx4_tlock(dev));
2902 spin_unlock_irq(mlx4_tlock(dev));
2905 static void rem_slave_mrs(struct mlx4_dev *dev, int slave)
2907 struct mlx4_priv *priv = mlx4_priv(dev);
2908 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
2909 struct list_head *mpt_list =
2910 &tracker->slave_list[slave].res_list[RES_MPT];
2911 struct res_mpt *mpt;
2912 struct res_mpt *tmp;
2919 err = move_all_busy(dev, slave, RES_MPT);
2921 mlx4_warn(dev, "rem_slave_mrs: Could not move all mpts to "
2922 "busy for slave %d\n", slave);
2924 spin_lock_irq(mlx4_tlock(dev));
2925 list_for_each_entry_safe(mpt, tmp, mpt_list, com.list) {
2926 spin_unlock_irq(mlx4_tlock(dev));
2927 if (mpt->com.owner == slave) {
2928 mptn = mpt->com.res_id;
2929 state = mpt->com.from_state;
2930 while (state != 0) {
2932 case RES_MPT_RESERVED:
2933 __mlx4_mr_release(dev, mpt->key);
2934 spin_lock_irq(mlx4_tlock(dev));
2935 radix_tree_delete(&tracker->res_tree[RES_MPT],
2937 list_del(&mpt->com.list);
2938 spin_unlock_irq(mlx4_tlock(dev));
2943 case RES_MPT_MAPPED:
2944 __mlx4_mr_free_icm(dev, mpt->key);
2945 state = RES_MPT_RESERVED;
2950 err = mlx4_cmd(dev, in_param, mptn, 0,
2952 MLX4_CMD_TIME_CLASS_A,
2955 mlx4_dbg(dev, "rem_slave_mrs: failed"
2956 " to move slave %d mpt %d to"
2960 atomic_dec(&mpt->mtt->ref_count);
2961 state = RES_MPT_MAPPED;
2968 spin_lock_irq(mlx4_tlock(dev));
2970 spin_unlock_irq(mlx4_tlock(dev));
2973 static void rem_slave_mtts(struct mlx4_dev *dev, int slave)
2975 struct mlx4_priv *priv = mlx4_priv(dev);
2976 struct mlx4_resource_tracker *tracker =
2977 &priv->mfunc.master.res_tracker;
2978 struct list_head *mtt_list =
2979 &tracker->slave_list[slave].res_list[RES_MTT];
2980 struct res_mtt *mtt;
2981 struct res_mtt *tmp;
2987 err = move_all_busy(dev, slave, RES_MTT);
2989 mlx4_warn(dev, "rem_slave_mtts: Could not move all mtts to "
2990 "busy for slave %d\n", slave);
2992 spin_lock_irq(mlx4_tlock(dev));
2993 list_for_each_entry_safe(mtt, tmp, mtt_list, com.list) {
2994 spin_unlock_irq(mlx4_tlock(dev));
2995 if (mtt->com.owner == slave) {
2996 base = mtt->com.res_id;
2997 state = mtt->com.from_state;
2998 while (state != 0) {
3000 case RES_MTT_ALLOCATED:
3001 __mlx4_free_mtt_range(dev, base,
3003 spin_lock_irq(mlx4_tlock(dev));
3004 radix_tree_delete(&tracker->res_tree[RES_MTT],
3006 list_del(&mtt->com.list);
3007 spin_unlock_irq(mlx4_tlock(dev));
3017 spin_lock_irq(mlx4_tlock(dev));
3019 spin_unlock_irq(mlx4_tlock(dev));
3022 static void rem_slave_eqs(struct mlx4_dev *dev, int slave)
3024 struct mlx4_priv *priv = mlx4_priv(dev);
3025 struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;
3026 struct list_head *eq_list =
3027 &tracker->slave_list[slave].res_list[RES_EQ];
3034 struct mlx4_cmd_mailbox *mailbox;
3036 err = move_all_busy(dev, slave, RES_EQ);
3038 mlx4_warn(dev, "rem_slave_eqs: Could not move all eqs to "
3039 "busy for slave %d\n", slave);
3041 spin_lock_irq(mlx4_tlock(dev));
3042 list_for_each_entry_safe(eq, tmp, eq_list, com.list) {
3043 spin_unlock_irq(mlx4_tlock(dev));
3044 if (eq->com.owner == slave) {
3045 eqn = eq->com.res_id;
3046 state = eq->com.from_state;
3047 while (state != 0) {
3049 case RES_EQ_RESERVED:
3050 spin_lock_irq(mlx4_tlock(dev));
3051 radix_tree_delete(&tracker->res_tree[RES_EQ],
3053 list_del(&eq->com.list);
3054 spin_unlock_irq(mlx4_tlock(dev));
3060 mailbox = mlx4_alloc_cmd_mailbox(dev);
3061 if (IS_ERR(mailbox)) {
3065 err = mlx4_cmd_box(dev, slave, 0,
3068 MLX4_CMD_TIME_CLASS_A,
3070 mlx4_dbg(dev, "rem_slave_eqs: failed"
3071 " to move slave %d eqs %d to"
3072 " SW ownership\n", slave, eqn);
3073 mlx4_free_cmd_mailbox(dev, mailbox);
3075 atomic_dec(&eq->mtt->ref_count);
3076 state = RES_EQ_RESERVED;
3085 spin_lock_irq(mlx4_tlock(dev));
3087 spin_unlock_irq(mlx4_tlock(dev));
3090 void mlx4_delete_all_resources_for_slave(struct mlx4_dev *dev, int slave)
3092 struct mlx4_priv *priv = mlx4_priv(dev);
3094 mutex_lock(&priv->mfunc.master.res_tracker.slave_list[slave].mutex);
3096 rem_slave_macs(dev, slave);
3097 rem_slave_qps(dev, slave);
3098 rem_slave_srqs(dev, slave);
3099 rem_slave_cqs(dev, slave);
3100 rem_slave_mrs(dev, slave);
3101 rem_slave_eqs(dev, slave);
3102 rem_slave_mtts(dev, slave);
3103 mutex_unlock(&priv->mfunc.master.res_tracker.slave_list[slave].mutex);