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>
44 #include <linux/if_ether.h>
45 #include <linux/etherdevice.h>
49 #include "mlx4_stats.h"
51 #define MLX4_MAC_VALID (1ull << 63)
52 #define MLX4_PF_COUNTERS_PER_PORT 2
53 #define MLX4_VF_COUNTERS_PER_PORT 1
56 struct list_head list
;
64 struct list_head list
;
72 struct list_head list
;
87 struct list_head list
;
89 enum mlx4_protocol prot
;
90 enum mlx4_steer_type steer
;
95 RES_QP_BUSY
= RES_ANY_BUSY
,
97 /* QP number was allocated */
100 /* ICM memory for QP context was mapped */
103 /* QP is in hw ownership */
108 struct res_common com
;
113 struct list_head mcg_list
;
118 /* saved qp params before VST enforcement in order to restore on VGT */
128 enum res_mtt_states
{
129 RES_MTT_BUSY
= RES_ANY_BUSY
,
133 static inline const char *mtt_states_str(enum res_mtt_states state
)
136 case RES_MTT_BUSY
: return "RES_MTT_BUSY";
137 case RES_MTT_ALLOCATED
: return "RES_MTT_ALLOCATED";
138 default: return "Unknown";
143 struct res_common com
;
148 enum res_mpt_states
{
149 RES_MPT_BUSY
= RES_ANY_BUSY
,
156 struct res_common com
;
162 RES_EQ_BUSY
= RES_ANY_BUSY
,
168 struct res_common com
;
173 RES_CQ_BUSY
= RES_ANY_BUSY
,
179 struct res_common com
;
184 enum res_srq_states
{
185 RES_SRQ_BUSY
= RES_ANY_BUSY
,
191 struct res_common com
;
197 enum res_counter_states
{
198 RES_COUNTER_BUSY
= RES_ANY_BUSY
,
199 RES_COUNTER_ALLOCATED
,
203 struct res_common com
;
207 enum res_xrcdn_states
{
208 RES_XRCD_BUSY
= RES_ANY_BUSY
,
213 struct res_common com
;
217 enum res_fs_rule_states
{
218 RES_FS_RULE_BUSY
= RES_ANY_BUSY
,
219 RES_FS_RULE_ALLOCATED
,
223 struct res_common com
;
225 /* VF DMFS mbox with port flipped */
227 /* > 0 --> apply mirror when getting into HA mode */
228 /* = 0 --> un-apply mirror when getting out of HA mode */
230 struct list_head mirr_list
;
234 static void *res_tracker_lookup(struct rb_root
*root
, u64 res_id
)
236 struct rb_node
*node
= root
->rb_node
;
239 struct res_common
*res
= container_of(node
, struct res_common
,
242 if (res_id
< res
->res_id
)
243 node
= node
->rb_left
;
244 else if (res_id
> res
->res_id
)
245 node
= node
->rb_right
;
252 static int res_tracker_insert(struct rb_root
*root
, struct res_common
*res
)
254 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
256 /* Figure out where to put new node */
258 struct res_common
*this = container_of(*new, struct res_common
,
262 if (res
->res_id
< this->res_id
)
263 new = &((*new)->rb_left
);
264 else if (res
->res_id
> this->res_id
)
265 new = &((*new)->rb_right
);
270 /* Add new node and rebalance tree. */
271 rb_link_node(&res
->node
, parent
, new);
272 rb_insert_color(&res
->node
, root
);
287 static const char *resource_str(enum mlx4_resource rt
)
290 case RES_QP
: return "RES_QP";
291 case RES_CQ
: return "RES_CQ";
292 case RES_SRQ
: return "RES_SRQ";
293 case RES_MPT
: return "RES_MPT";
294 case RES_MTT
: return "RES_MTT";
295 case RES_MAC
: return "RES_MAC";
296 case RES_VLAN
: return "RES_VLAN";
297 case RES_EQ
: return "RES_EQ";
298 case RES_COUNTER
: return "RES_COUNTER";
299 case RES_FS_RULE
: return "RES_FS_RULE";
300 case RES_XRCD
: return "RES_XRCD";
301 default: return "Unknown resource type !!!";
305 static void rem_slave_vlans(struct mlx4_dev
*dev
, int slave
);
306 static inline int mlx4_grant_resource(struct mlx4_dev
*dev
, int slave
,
307 enum mlx4_resource res_type
, int count
,
310 struct mlx4_priv
*priv
= mlx4_priv(dev
);
311 struct resource_allocator
*res_alloc
=
312 &priv
->mfunc
.master
.res_tracker
.res_alloc
[res_type
];
314 int allocated
, free
, reserved
, guaranteed
, from_free
;
317 if (slave
> dev
->persist
->num_vfs
)
320 spin_lock(&res_alloc
->alloc_lock
);
321 allocated
= (port
> 0) ?
322 res_alloc
->allocated
[(port
- 1) *
323 (dev
->persist
->num_vfs
+ 1) + slave
] :
324 res_alloc
->allocated
[slave
];
325 free
= (port
> 0) ? res_alloc
->res_port_free
[port
- 1] :
327 reserved
= (port
> 0) ? res_alloc
->res_port_rsvd
[port
- 1] :
328 res_alloc
->res_reserved
;
329 guaranteed
= res_alloc
->guaranteed
[slave
];
331 if (allocated
+ count
> res_alloc
->quota
[slave
]) {
332 mlx4_warn(dev
, "VF %d port %d res %s: quota exceeded, count %d alloc %d quota %d\n",
333 slave
, port
, resource_str(res_type
), count
,
334 allocated
, res_alloc
->quota
[slave
]);
338 if (allocated
+ count
<= guaranteed
) {
342 /* portion may need to be obtained from free area */
343 if (guaranteed
- allocated
> 0)
344 from_free
= count
- (guaranteed
- allocated
);
348 from_rsvd
= count
- from_free
;
350 if (free
- from_free
>= reserved
)
353 mlx4_warn(dev
, "VF %d port %d res %s: free pool empty, free %d from_free %d rsvd %d\n",
354 slave
, port
, resource_str(res_type
), free
,
355 from_free
, reserved
);
359 /* grant the request */
361 res_alloc
->allocated
[(port
- 1) *
362 (dev
->persist
->num_vfs
+ 1) + slave
] += count
;
363 res_alloc
->res_port_free
[port
- 1] -= count
;
364 res_alloc
->res_port_rsvd
[port
- 1] -= from_rsvd
;
366 res_alloc
->allocated
[slave
] += count
;
367 res_alloc
->res_free
-= count
;
368 res_alloc
->res_reserved
-= from_rsvd
;
373 spin_unlock(&res_alloc
->alloc_lock
);
377 static inline void mlx4_release_resource(struct mlx4_dev
*dev
, int slave
,
378 enum mlx4_resource res_type
, int count
,
381 struct mlx4_priv
*priv
= mlx4_priv(dev
);
382 struct resource_allocator
*res_alloc
=
383 &priv
->mfunc
.master
.res_tracker
.res_alloc
[res_type
];
384 int allocated
, guaranteed
, from_rsvd
;
386 if (slave
> dev
->persist
->num_vfs
)
389 spin_lock(&res_alloc
->alloc_lock
);
391 allocated
= (port
> 0) ?
392 res_alloc
->allocated
[(port
- 1) *
393 (dev
->persist
->num_vfs
+ 1) + slave
] :
394 res_alloc
->allocated
[slave
];
395 guaranteed
= res_alloc
->guaranteed
[slave
];
397 if (allocated
- count
>= guaranteed
) {
400 /* portion may need to be returned to reserved area */
401 if (allocated
- guaranteed
> 0)
402 from_rsvd
= count
- (allocated
- guaranteed
);
408 res_alloc
->allocated
[(port
- 1) *
409 (dev
->persist
->num_vfs
+ 1) + slave
] -= count
;
410 res_alloc
->res_port_free
[port
- 1] += count
;
411 res_alloc
->res_port_rsvd
[port
- 1] += from_rsvd
;
413 res_alloc
->allocated
[slave
] -= count
;
414 res_alloc
->res_free
+= count
;
415 res_alloc
->res_reserved
+= from_rsvd
;
418 spin_unlock(&res_alloc
->alloc_lock
);
422 static inline void initialize_res_quotas(struct mlx4_dev
*dev
,
423 struct resource_allocator
*res_alloc
,
424 enum mlx4_resource res_type
,
425 int vf
, int num_instances
)
427 res_alloc
->guaranteed
[vf
] = num_instances
/
428 (2 * (dev
->persist
->num_vfs
+ 1));
429 res_alloc
->quota
[vf
] = (num_instances
/ 2) + res_alloc
->guaranteed
[vf
];
430 if (vf
== mlx4_master_func_num(dev
)) {
431 res_alloc
->res_free
= num_instances
;
432 if (res_type
== RES_MTT
) {
433 /* reserved mtts will be taken out of the PF allocation */
434 res_alloc
->res_free
+= dev
->caps
.reserved_mtts
;
435 res_alloc
->guaranteed
[vf
] += dev
->caps
.reserved_mtts
;
436 res_alloc
->quota
[vf
] += dev
->caps
.reserved_mtts
;
441 void mlx4_init_quotas(struct mlx4_dev
*dev
)
443 struct mlx4_priv
*priv
= mlx4_priv(dev
);
446 /* quotas for VFs are initialized in mlx4_slave_cap */
447 if (mlx4_is_slave(dev
))
450 if (!mlx4_is_mfunc(dev
)) {
451 dev
->quotas
.qp
= dev
->caps
.num_qps
- dev
->caps
.reserved_qps
-
452 mlx4_num_reserved_sqps(dev
);
453 dev
->quotas
.cq
= dev
->caps
.num_cqs
- dev
->caps
.reserved_cqs
;
454 dev
->quotas
.srq
= dev
->caps
.num_srqs
- dev
->caps
.reserved_srqs
;
455 dev
->quotas
.mtt
= dev
->caps
.num_mtts
- dev
->caps
.reserved_mtts
;
456 dev
->quotas
.mpt
= dev
->caps
.num_mpts
- dev
->caps
.reserved_mrws
;
460 pf
= mlx4_master_func_num(dev
);
462 priv
->mfunc
.master
.res_tracker
.res_alloc
[RES_QP
].quota
[pf
];
464 priv
->mfunc
.master
.res_tracker
.res_alloc
[RES_CQ
].quota
[pf
];
466 priv
->mfunc
.master
.res_tracker
.res_alloc
[RES_SRQ
].quota
[pf
];
468 priv
->mfunc
.master
.res_tracker
.res_alloc
[RES_MTT
].quota
[pf
];
470 priv
->mfunc
.master
.res_tracker
.res_alloc
[RES_MPT
].quota
[pf
];
473 static int get_max_gauranteed_vfs_counter(struct mlx4_dev
*dev
)
475 /* reduce the sink counter */
476 return (dev
->caps
.max_counters
- 1 -
477 (MLX4_PF_COUNTERS_PER_PORT
* MLX4_MAX_PORTS
))
481 int mlx4_init_resource_tracker(struct mlx4_dev
*dev
)
483 struct mlx4_priv
*priv
= mlx4_priv(dev
);
486 int max_vfs_guarantee_counter
= get_max_gauranteed_vfs_counter(dev
);
488 priv
->mfunc
.master
.res_tracker
.slave_list
=
489 kzalloc(dev
->num_slaves
* sizeof(struct slave_list
),
491 if (!priv
->mfunc
.master
.res_tracker
.slave_list
)
494 for (i
= 0 ; i
< dev
->num_slaves
; i
++) {
495 for (t
= 0; t
< MLX4_NUM_OF_RESOURCE_TYPE
; ++t
)
496 INIT_LIST_HEAD(&priv
->mfunc
.master
.res_tracker
.
497 slave_list
[i
].res_list
[t
]);
498 mutex_init(&priv
->mfunc
.master
.res_tracker
.slave_list
[i
].mutex
);
501 mlx4_dbg(dev
, "Started init_resource_tracker: %ld slaves\n",
503 for (i
= 0 ; i
< MLX4_NUM_OF_RESOURCE_TYPE
; i
++)
504 priv
->mfunc
.master
.res_tracker
.res_tree
[i
] = RB_ROOT
;
506 for (i
= 0; i
< MLX4_NUM_OF_RESOURCE_TYPE
; i
++) {
507 struct resource_allocator
*res_alloc
=
508 &priv
->mfunc
.master
.res_tracker
.res_alloc
[i
];
509 res_alloc
->quota
= kmalloc((dev
->persist
->num_vfs
+ 1) *
510 sizeof(int), GFP_KERNEL
);
511 res_alloc
->guaranteed
= kmalloc((dev
->persist
->num_vfs
+ 1) *
512 sizeof(int), GFP_KERNEL
);
513 if (i
== RES_MAC
|| i
== RES_VLAN
)
514 res_alloc
->allocated
= kzalloc(MLX4_MAX_PORTS
*
515 (dev
->persist
->num_vfs
517 sizeof(int), GFP_KERNEL
);
519 res_alloc
->allocated
= kzalloc((dev
->persist
->
521 sizeof(int), GFP_KERNEL
);
522 /* Reduce the sink counter */
523 if (i
== RES_COUNTER
)
524 res_alloc
->res_free
= dev
->caps
.max_counters
- 1;
526 if (!res_alloc
->quota
|| !res_alloc
->guaranteed
||
527 !res_alloc
->allocated
)
530 spin_lock_init(&res_alloc
->alloc_lock
);
531 for (t
= 0; t
< dev
->persist
->num_vfs
+ 1; t
++) {
532 struct mlx4_active_ports actv_ports
=
533 mlx4_get_active_ports(dev
, t
);
536 initialize_res_quotas(dev
, res_alloc
, RES_QP
,
537 t
, dev
->caps
.num_qps
-
538 dev
->caps
.reserved_qps
-
539 mlx4_num_reserved_sqps(dev
));
542 initialize_res_quotas(dev
, res_alloc
, RES_CQ
,
543 t
, dev
->caps
.num_cqs
-
544 dev
->caps
.reserved_cqs
);
547 initialize_res_quotas(dev
, res_alloc
, RES_SRQ
,
548 t
, dev
->caps
.num_srqs
-
549 dev
->caps
.reserved_srqs
);
552 initialize_res_quotas(dev
, res_alloc
, RES_MPT
,
553 t
, dev
->caps
.num_mpts
-
554 dev
->caps
.reserved_mrws
);
557 initialize_res_quotas(dev
, res_alloc
, RES_MTT
,
558 t
, dev
->caps
.num_mtts
-
559 dev
->caps
.reserved_mtts
);
562 if (t
== mlx4_master_func_num(dev
)) {
563 int max_vfs_pport
= 0;
564 /* Calculate the max vfs per port for */
566 for (j
= 0; j
< dev
->caps
.num_ports
;
568 struct mlx4_slaves_pport slaves_pport
=
569 mlx4_phys_to_slaves_pport(dev
, j
+ 1);
570 unsigned current_slaves
=
571 bitmap_weight(slaves_pport
.slaves
,
572 dev
->caps
.num_ports
) - 1;
573 if (max_vfs_pport
< current_slaves
)
577 res_alloc
->quota
[t
] =
580 res_alloc
->guaranteed
[t
] = 2;
581 for (j
= 0; j
< MLX4_MAX_PORTS
; j
++)
582 res_alloc
->res_port_free
[j
] =
585 res_alloc
->quota
[t
] = MLX4_MAX_MAC_NUM
;
586 res_alloc
->guaranteed
[t
] = 2;
590 if (t
== mlx4_master_func_num(dev
)) {
591 res_alloc
->quota
[t
] = MLX4_MAX_VLAN_NUM
;
592 res_alloc
->guaranteed
[t
] = MLX4_MAX_VLAN_NUM
/ 2;
593 for (j
= 0; j
< MLX4_MAX_PORTS
; j
++)
594 res_alloc
->res_port_free
[j
] =
597 res_alloc
->quota
[t
] = MLX4_MAX_VLAN_NUM
/ 2;
598 res_alloc
->guaranteed
[t
] = 0;
602 res_alloc
->quota
[t
] = dev
->caps
.max_counters
;
603 if (t
== mlx4_master_func_num(dev
))
604 res_alloc
->guaranteed
[t
] =
605 MLX4_PF_COUNTERS_PER_PORT
*
607 else if (t
<= max_vfs_guarantee_counter
)
608 res_alloc
->guaranteed
[t
] =
609 MLX4_VF_COUNTERS_PER_PORT
*
612 res_alloc
->guaranteed
[t
] = 0;
613 res_alloc
->res_free
-= res_alloc
->guaranteed
[t
];
618 if (i
== RES_MAC
|| i
== RES_VLAN
) {
619 for (j
= 0; j
< dev
->caps
.num_ports
; j
++)
620 if (test_bit(j
, actv_ports
.ports
))
621 res_alloc
->res_port_rsvd
[j
] +=
622 res_alloc
->guaranteed
[t
];
624 res_alloc
->res_reserved
+= res_alloc
->guaranteed
[t
];
628 spin_lock_init(&priv
->mfunc
.master
.res_tracker
.lock
);
632 for (i
= 0; i
< MLX4_NUM_OF_RESOURCE_TYPE
; i
++) {
633 kfree(priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].allocated
);
634 priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].allocated
= NULL
;
635 kfree(priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].guaranteed
);
636 priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].guaranteed
= NULL
;
637 kfree(priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].quota
);
638 priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].quota
= NULL
;
643 void mlx4_free_resource_tracker(struct mlx4_dev
*dev
,
644 enum mlx4_res_tracker_free_type type
)
646 struct mlx4_priv
*priv
= mlx4_priv(dev
);
649 if (priv
->mfunc
.master
.res_tracker
.slave_list
) {
650 if (type
!= RES_TR_FREE_STRUCTS_ONLY
) {
651 for (i
= 0; i
< dev
->num_slaves
; i
++) {
652 if (type
== RES_TR_FREE_ALL
||
653 dev
->caps
.function
!= i
)
654 mlx4_delete_all_resources_for_slave(dev
, i
);
656 /* free master's vlans */
657 i
= dev
->caps
.function
;
658 mlx4_reset_roce_gids(dev
, i
);
659 mutex_lock(&priv
->mfunc
.master
.res_tracker
.slave_list
[i
].mutex
);
660 rem_slave_vlans(dev
, i
);
661 mutex_unlock(&priv
->mfunc
.master
.res_tracker
.slave_list
[i
].mutex
);
664 if (type
!= RES_TR_FREE_SLAVES_ONLY
) {
665 for (i
= 0; i
< MLX4_NUM_OF_RESOURCE_TYPE
; i
++) {
666 kfree(priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].allocated
);
667 priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].allocated
= NULL
;
668 kfree(priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].guaranteed
);
669 priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].guaranteed
= NULL
;
670 kfree(priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].quota
);
671 priv
->mfunc
.master
.res_tracker
.res_alloc
[i
].quota
= NULL
;
673 kfree(priv
->mfunc
.master
.res_tracker
.slave_list
);
674 priv
->mfunc
.master
.res_tracker
.slave_list
= NULL
;
679 static void update_pkey_index(struct mlx4_dev
*dev
, int slave
,
680 struct mlx4_cmd_mailbox
*inbox
)
682 u8 sched
= *(u8
*)(inbox
->buf
+ 64);
683 u8 orig_index
= *(u8
*)(inbox
->buf
+ 35);
685 struct mlx4_priv
*priv
= mlx4_priv(dev
);
688 port
= (sched
>> 6 & 1) + 1;
690 new_index
= priv
->virt2phys_pkey
[slave
][port
- 1][orig_index
];
691 *(u8
*)(inbox
->buf
+ 35) = new_index
;
694 static void update_gid(struct mlx4_dev
*dev
, struct mlx4_cmd_mailbox
*inbox
,
697 struct mlx4_qp_context
*qp_ctx
= inbox
->buf
+ 8;
698 enum mlx4_qp_optpar optpar
= be32_to_cpu(*(__be32
*) inbox
->buf
);
699 u32 ts
= (be32_to_cpu(qp_ctx
->flags
) >> 16) & 0xff;
702 if (MLX4_QP_ST_UD
== ts
) {
703 port
= (qp_ctx
->pri_path
.sched_queue
>> 6 & 1) + 1;
704 if (mlx4_is_eth(dev
, port
))
705 qp_ctx
->pri_path
.mgid_index
=
706 mlx4_get_base_gid_ix(dev
, slave
, port
) | 0x80;
708 qp_ctx
->pri_path
.mgid_index
= slave
| 0x80;
710 } else if (MLX4_QP_ST_RC
== ts
|| MLX4_QP_ST_XRC
== ts
|| MLX4_QP_ST_UC
== ts
) {
711 if (optpar
& MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH
) {
712 port
= (qp_ctx
->pri_path
.sched_queue
>> 6 & 1) + 1;
713 if (mlx4_is_eth(dev
, port
)) {
714 qp_ctx
->pri_path
.mgid_index
+=
715 mlx4_get_base_gid_ix(dev
, slave
, port
);
716 qp_ctx
->pri_path
.mgid_index
&= 0x7f;
718 qp_ctx
->pri_path
.mgid_index
= slave
& 0x7F;
721 if (optpar
& MLX4_QP_OPTPAR_ALT_ADDR_PATH
) {
722 port
= (qp_ctx
->alt_path
.sched_queue
>> 6 & 1) + 1;
723 if (mlx4_is_eth(dev
, port
)) {
724 qp_ctx
->alt_path
.mgid_index
+=
725 mlx4_get_base_gid_ix(dev
, slave
, port
);
726 qp_ctx
->alt_path
.mgid_index
&= 0x7f;
728 qp_ctx
->alt_path
.mgid_index
= slave
& 0x7F;
734 static int handle_counter(struct mlx4_dev
*dev
, struct mlx4_qp_context
*qpc
,
737 static int update_vport_qp_param(struct mlx4_dev
*dev
,
738 struct mlx4_cmd_mailbox
*inbox
,
741 struct mlx4_qp_context
*qpc
= inbox
->buf
+ 8;
742 struct mlx4_vport_oper_state
*vp_oper
;
743 struct mlx4_priv
*priv
;
747 port
= (qpc
->pri_path
.sched_queue
& 0x40) ? 2 : 1;
748 priv
= mlx4_priv(dev
);
749 vp_oper
= &priv
->mfunc
.master
.vf_oper
[slave
].vport
[port
];
750 qp_type
= (be32_to_cpu(qpc
->flags
) >> 16) & 0xff;
752 err
= handle_counter(dev
, qpc
, slave
, port
);
756 if (MLX4_VGT
!= vp_oper
->state
.default_vlan
) {
757 /* the reserved QPs (special, proxy, tunnel)
758 * do not operate over vlans
760 if (mlx4_is_qp_reserved(dev
, qpn
))
763 /* force strip vlan by clear vsd, MLX QP refers to Raw Ethernet */
764 if (qp_type
== MLX4_QP_ST_UD
||
765 (qp_type
== MLX4_QP_ST_MLX
&& mlx4_is_eth(dev
, port
))) {
766 if (dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_VSD_INIT2RTR
) {
767 *(__be32
*)inbox
->buf
=
768 cpu_to_be32(be32_to_cpu(*(__be32
*)inbox
->buf
) |
769 MLX4_QP_OPTPAR_VLAN_STRIPPING
);
770 qpc
->param3
&= ~cpu_to_be32(MLX4_STRIP_VLAN
);
772 struct mlx4_update_qp_params params
= {.flags
= 0};
774 err
= mlx4_update_qp(dev
, qpn
, MLX4_UPDATE_QP_VSD
, ¶ms
);
780 /* preserve IF_COUNTER flag */
781 qpc
->pri_path
.vlan_control
&=
782 MLX4_CTRL_ETH_SRC_CHECK_IF_COUNTER
;
783 if (vp_oper
->state
.link_state
== IFLA_VF_LINK_STATE_DISABLE
&&
784 dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_UPDATE_QP
) {
785 qpc
->pri_path
.vlan_control
|=
786 MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED
|
787 MLX4_VLAN_CTRL_ETH_TX_BLOCK_PRIO_TAGGED
|
788 MLX4_VLAN_CTRL_ETH_TX_BLOCK_UNTAGGED
|
789 MLX4_VLAN_CTRL_ETH_RX_BLOCK_PRIO_TAGGED
|
790 MLX4_VLAN_CTRL_ETH_RX_BLOCK_UNTAGGED
|
791 MLX4_VLAN_CTRL_ETH_RX_BLOCK_TAGGED
;
792 } else if (0 != vp_oper
->state
.default_vlan
) {
793 qpc
->pri_path
.vlan_control
|=
794 MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED
|
795 MLX4_VLAN_CTRL_ETH_RX_BLOCK_PRIO_TAGGED
|
796 MLX4_VLAN_CTRL_ETH_RX_BLOCK_UNTAGGED
;
797 } else { /* priority tagged */
798 qpc
->pri_path
.vlan_control
|=
799 MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED
|
800 MLX4_VLAN_CTRL_ETH_RX_BLOCK_TAGGED
;
803 qpc
->pri_path
.fvl_rx
|= MLX4_FVL_RX_FORCE_ETH_VLAN
;
804 qpc
->pri_path
.vlan_index
= vp_oper
->vlan_idx
;
805 qpc
->pri_path
.fl
|= MLX4_FL_CV
| MLX4_FL_ETH_HIDE_CQE_VLAN
;
806 qpc
->pri_path
.feup
|= MLX4_FEUP_FORCE_ETH_UP
| MLX4_FVL_FORCE_ETH_VLAN
;
807 qpc
->pri_path
.sched_queue
&= 0xC7;
808 qpc
->pri_path
.sched_queue
|= (vp_oper
->state
.default_qos
) << 3;
809 qpc
->qos_vport
= vp_oper
->state
.qos_vport
;
811 if (vp_oper
->state
.spoofchk
) {
812 qpc
->pri_path
.feup
|= MLX4_FSM_FORCE_ETH_SRC_MAC
;
813 qpc
->pri_path
.grh_mylmc
= (0x80 & qpc
->pri_path
.grh_mylmc
) + vp_oper
->mac_idx
;
819 static int mpt_mask(struct mlx4_dev
*dev
)
821 return dev
->caps
.num_mpts
- 1;
824 static void *find_res(struct mlx4_dev
*dev
, u64 res_id
,
825 enum mlx4_resource type
)
827 struct mlx4_priv
*priv
= mlx4_priv(dev
);
829 return res_tracker_lookup(&priv
->mfunc
.master
.res_tracker
.res_tree
[type
],
833 static int get_res(struct mlx4_dev
*dev
, int slave
, u64 res_id
,
834 enum mlx4_resource type
,
837 struct res_common
*r
;
840 spin_lock_irq(mlx4_tlock(dev
));
841 r
= find_res(dev
, res_id
, type
);
847 if (r
->state
== RES_ANY_BUSY
) {
852 if (r
->owner
!= slave
) {
857 r
->from_state
= r
->state
;
858 r
->state
= RES_ANY_BUSY
;
861 *((struct res_common
**)res
) = r
;
864 spin_unlock_irq(mlx4_tlock(dev
));
868 int mlx4_get_slave_from_resource_id(struct mlx4_dev
*dev
,
869 enum mlx4_resource type
,
870 u64 res_id
, int *slave
)
873 struct res_common
*r
;
879 spin_lock(mlx4_tlock(dev
));
881 r
= find_res(dev
, id
, type
);
886 spin_unlock(mlx4_tlock(dev
));
891 static void put_res(struct mlx4_dev
*dev
, int slave
, u64 res_id
,
892 enum mlx4_resource type
)
894 struct res_common
*r
;
896 spin_lock_irq(mlx4_tlock(dev
));
897 r
= find_res(dev
, res_id
, type
);
899 r
->state
= r
->from_state
;
900 spin_unlock_irq(mlx4_tlock(dev
));
903 static int counter_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
904 u64 in_param
, u64
*out_param
, int port
);
906 static int handle_existing_counter(struct mlx4_dev
*dev
, u8 slave
, int port
,
909 struct res_common
*r
;
910 struct res_counter
*counter
;
913 if (counter_index
== MLX4_SINK_COUNTER_INDEX(dev
))
916 spin_lock_irq(mlx4_tlock(dev
));
917 r
= find_res(dev
, counter_index
, RES_COUNTER
);
918 if (!r
|| r
->owner
!= slave
)
920 counter
= container_of(r
, struct res_counter
, com
);
922 counter
->port
= port
;
924 spin_unlock_irq(mlx4_tlock(dev
));
928 static int handle_unexisting_counter(struct mlx4_dev
*dev
,
929 struct mlx4_qp_context
*qpc
, u8 slave
,
932 struct mlx4_priv
*priv
= mlx4_priv(dev
);
933 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
934 struct res_common
*tmp
;
935 struct res_counter
*counter
;
936 u64 counter_idx
= MLX4_SINK_COUNTER_INDEX(dev
);
939 spin_lock_irq(mlx4_tlock(dev
));
940 list_for_each_entry(tmp
,
941 &tracker
->slave_list
[slave
].res_list
[RES_COUNTER
],
943 counter
= container_of(tmp
, struct res_counter
, com
);
944 if (port
== counter
->port
) {
945 qpc
->pri_path
.counter_index
= counter
->com
.res_id
;
946 spin_unlock_irq(mlx4_tlock(dev
));
950 spin_unlock_irq(mlx4_tlock(dev
));
952 /* No existing counter, need to allocate a new counter */
953 err
= counter_alloc_res(dev
, slave
, RES_OP_RESERVE
, 0, 0, &counter_idx
,
955 if (err
== -ENOENT
) {
957 } else if (err
&& err
!= -ENOSPC
) {
958 mlx4_err(dev
, "%s: failed to create new counter for slave %d err %d\n",
959 __func__
, slave
, err
);
961 qpc
->pri_path
.counter_index
= counter_idx
;
962 mlx4_dbg(dev
, "%s: alloc new counter for slave %d index %d\n",
963 __func__
, slave
, qpc
->pri_path
.counter_index
);
970 static int handle_counter(struct mlx4_dev
*dev
, struct mlx4_qp_context
*qpc
,
973 if (qpc
->pri_path
.counter_index
!= MLX4_SINK_COUNTER_INDEX(dev
))
974 return handle_existing_counter(dev
, slave
, port
,
975 qpc
->pri_path
.counter_index
);
977 return handle_unexisting_counter(dev
, qpc
, slave
, port
);
980 static struct res_common
*alloc_qp_tr(int id
)
984 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
988 ret
->com
.res_id
= id
;
989 ret
->com
.state
= RES_QP_RESERVED
;
991 INIT_LIST_HEAD(&ret
->mcg_list
);
992 spin_lock_init(&ret
->mcg_spl
);
993 atomic_set(&ret
->ref_count
, 0);
998 static struct res_common
*alloc_mtt_tr(int id
, int order
)
1000 struct res_mtt
*ret
;
1002 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1006 ret
->com
.res_id
= id
;
1008 ret
->com
.state
= RES_MTT_ALLOCATED
;
1009 atomic_set(&ret
->ref_count
, 0);
1014 static struct res_common
*alloc_mpt_tr(int id
, int key
)
1016 struct res_mpt
*ret
;
1018 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1022 ret
->com
.res_id
= id
;
1023 ret
->com
.state
= RES_MPT_RESERVED
;
1029 static struct res_common
*alloc_eq_tr(int id
)
1033 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1037 ret
->com
.res_id
= id
;
1038 ret
->com
.state
= RES_EQ_RESERVED
;
1043 static struct res_common
*alloc_cq_tr(int id
)
1047 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1051 ret
->com
.res_id
= id
;
1052 ret
->com
.state
= RES_CQ_ALLOCATED
;
1053 atomic_set(&ret
->ref_count
, 0);
1058 static struct res_common
*alloc_srq_tr(int id
)
1060 struct res_srq
*ret
;
1062 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1066 ret
->com
.res_id
= id
;
1067 ret
->com
.state
= RES_SRQ_ALLOCATED
;
1068 atomic_set(&ret
->ref_count
, 0);
1073 static struct res_common
*alloc_counter_tr(int id
, int port
)
1075 struct res_counter
*ret
;
1077 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1081 ret
->com
.res_id
= id
;
1082 ret
->com
.state
= RES_COUNTER_ALLOCATED
;
1088 static struct res_common
*alloc_xrcdn_tr(int id
)
1090 struct res_xrcdn
*ret
;
1092 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1096 ret
->com
.res_id
= id
;
1097 ret
->com
.state
= RES_XRCD_ALLOCATED
;
1102 static struct res_common
*alloc_fs_rule_tr(u64 id
, int qpn
)
1104 struct res_fs_rule
*ret
;
1106 ret
= kzalloc(sizeof *ret
, GFP_KERNEL
);
1110 ret
->com
.res_id
= id
;
1111 ret
->com
.state
= RES_FS_RULE_ALLOCATED
;
1116 static struct res_common
*alloc_tr(u64 id
, enum mlx4_resource type
, int slave
,
1119 struct res_common
*ret
;
1123 ret
= alloc_qp_tr(id
);
1126 ret
= alloc_mpt_tr(id
, extra
);
1129 ret
= alloc_mtt_tr(id
, extra
);
1132 ret
= alloc_eq_tr(id
);
1135 ret
= alloc_cq_tr(id
);
1138 ret
= alloc_srq_tr(id
);
1141 pr_err("implementation missing\n");
1144 ret
= alloc_counter_tr(id
, extra
);
1147 ret
= alloc_xrcdn_tr(id
);
1150 ret
= alloc_fs_rule_tr(id
, extra
);
1161 int mlx4_calc_vf_counters(struct mlx4_dev
*dev
, int slave
, int port
,
1162 struct mlx4_counter
*data
)
1164 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1165 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1166 struct res_common
*tmp
;
1167 struct res_counter
*counter
;
1171 memset(data
, 0, sizeof(*data
));
1173 counters_arr
= kmalloc_array(dev
->caps
.max_counters
,
1174 sizeof(*counters_arr
), GFP_KERNEL
);
1178 spin_lock_irq(mlx4_tlock(dev
));
1179 list_for_each_entry(tmp
,
1180 &tracker
->slave_list
[slave
].res_list
[RES_COUNTER
],
1182 counter
= container_of(tmp
, struct res_counter
, com
);
1183 if (counter
->port
== port
) {
1184 counters_arr
[i
] = (int)tmp
->res_id
;
1188 spin_unlock_irq(mlx4_tlock(dev
));
1189 counters_arr
[i
] = -1;
1193 while (counters_arr
[i
] != -1) {
1194 err
= mlx4_get_counter_stats(dev
, counters_arr
[i
], data
,
1197 memset(data
, 0, sizeof(*data
));
1204 kfree(counters_arr
);
1208 static int add_res_range(struct mlx4_dev
*dev
, int slave
, u64 base
, int count
,
1209 enum mlx4_resource type
, int extra
)
1213 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1214 struct res_common
**res_arr
;
1215 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1216 struct rb_root
*root
= &tracker
->res_tree
[type
];
1218 res_arr
= kzalloc(count
* sizeof *res_arr
, GFP_KERNEL
);
1222 for (i
= 0; i
< count
; ++i
) {
1223 res_arr
[i
] = alloc_tr(base
+ i
, type
, slave
, extra
);
1225 for (--i
; i
>= 0; --i
)
1233 spin_lock_irq(mlx4_tlock(dev
));
1234 for (i
= 0; i
< count
; ++i
) {
1235 if (find_res(dev
, base
+ i
, type
)) {
1239 err
= res_tracker_insert(root
, res_arr
[i
]);
1242 list_add_tail(&res_arr
[i
]->list
,
1243 &tracker
->slave_list
[slave
].res_list
[type
]);
1245 spin_unlock_irq(mlx4_tlock(dev
));
1251 for (--i
; i
>= 0; --i
) {
1252 rb_erase(&res_arr
[i
]->node
, root
);
1253 list_del_init(&res_arr
[i
]->list
);
1256 spin_unlock_irq(mlx4_tlock(dev
));
1258 for (i
= 0; i
< count
; ++i
)
1266 static int remove_qp_ok(struct res_qp
*res
)
1268 if (res
->com
.state
== RES_QP_BUSY
|| atomic_read(&res
->ref_count
) ||
1269 !list_empty(&res
->mcg_list
)) {
1270 pr_err("resource tracker: fail to remove qp, state %d, ref_count %d\n",
1271 res
->com
.state
, atomic_read(&res
->ref_count
));
1273 } else if (res
->com
.state
!= RES_QP_RESERVED
) {
1280 static int remove_mtt_ok(struct res_mtt
*res
, int order
)
1282 if (res
->com
.state
== RES_MTT_BUSY
||
1283 atomic_read(&res
->ref_count
)) {
1284 pr_devel("%s-%d: state %s, ref_count %d\n",
1286 mtt_states_str(res
->com
.state
),
1287 atomic_read(&res
->ref_count
));
1289 } else if (res
->com
.state
!= RES_MTT_ALLOCATED
)
1291 else if (res
->order
!= order
)
1297 static int remove_mpt_ok(struct res_mpt
*res
)
1299 if (res
->com
.state
== RES_MPT_BUSY
)
1301 else if (res
->com
.state
!= RES_MPT_RESERVED
)
1307 static int remove_eq_ok(struct res_eq
*res
)
1309 if (res
->com
.state
== RES_MPT_BUSY
)
1311 else if (res
->com
.state
!= RES_MPT_RESERVED
)
1317 static int remove_counter_ok(struct res_counter
*res
)
1319 if (res
->com
.state
== RES_COUNTER_BUSY
)
1321 else if (res
->com
.state
!= RES_COUNTER_ALLOCATED
)
1327 static int remove_xrcdn_ok(struct res_xrcdn
*res
)
1329 if (res
->com
.state
== RES_XRCD_BUSY
)
1331 else if (res
->com
.state
!= RES_XRCD_ALLOCATED
)
1337 static int remove_fs_rule_ok(struct res_fs_rule
*res
)
1339 if (res
->com
.state
== RES_FS_RULE_BUSY
)
1341 else if (res
->com
.state
!= RES_FS_RULE_ALLOCATED
)
1347 static int remove_cq_ok(struct res_cq
*res
)
1349 if (res
->com
.state
== RES_CQ_BUSY
)
1351 else if (res
->com
.state
!= RES_CQ_ALLOCATED
)
1357 static int remove_srq_ok(struct res_srq
*res
)
1359 if (res
->com
.state
== RES_SRQ_BUSY
)
1361 else if (res
->com
.state
!= RES_SRQ_ALLOCATED
)
1367 static int remove_ok(struct res_common
*res
, enum mlx4_resource type
, int extra
)
1371 return remove_qp_ok((struct res_qp
*)res
);
1373 return remove_cq_ok((struct res_cq
*)res
);
1375 return remove_srq_ok((struct res_srq
*)res
);
1377 return remove_mpt_ok((struct res_mpt
*)res
);
1379 return remove_mtt_ok((struct res_mtt
*)res
, extra
);
1383 return remove_eq_ok((struct res_eq
*)res
);
1385 return remove_counter_ok((struct res_counter
*)res
);
1387 return remove_xrcdn_ok((struct res_xrcdn
*)res
);
1389 return remove_fs_rule_ok((struct res_fs_rule
*)res
);
1395 static int rem_res_range(struct mlx4_dev
*dev
, int slave
, u64 base
, int count
,
1396 enum mlx4_resource type
, int extra
)
1400 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1401 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1402 struct res_common
*r
;
1404 spin_lock_irq(mlx4_tlock(dev
));
1405 for (i
= base
; i
< base
+ count
; ++i
) {
1406 r
= res_tracker_lookup(&tracker
->res_tree
[type
], i
);
1411 if (r
->owner
!= slave
) {
1415 err
= remove_ok(r
, type
, extra
);
1420 for (i
= base
; i
< base
+ count
; ++i
) {
1421 r
= res_tracker_lookup(&tracker
->res_tree
[type
], i
);
1422 rb_erase(&r
->node
, &tracker
->res_tree
[type
]);
1429 spin_unlock_irq(mlx4_tlock(dev
));
1434 static int qp_res_start_move_to(struct mlx4_dev
*dev
, int slave
, int qpn
,
1435 enum res_qp_states state
, struct res_qp
**qp
,
1438 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1439 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1443 spin_lock_irq(mlx4_tlock(dev
));
1444 r
= res_tracker_lookup(&tracker
->res_tree
[RES_QP
], qpn
);
1447 else if (r
->com
.owner
!= slave
)
1452 mlx4_dbg(dev
, "%s: failed RES_QP, 0x%llx\n",
1453 __func__
, r
->com
.res_id
);
1457 case RES_QP_RESERVED
:
1458 if (r
->com
.state
== RES_QP_MAPPED
&& !alloc
)
1461 mlx4_dbg(dev
, "failed RES_QP, 0x%llx\n", r
->com
.res_id
);
1466 if ((r
->com
.state
== RES_QP_RESERVED
&& alloc
) ||
1467 r
->com
.state
== RES_QP_HW
)
1470 mlx4_dbg(dev
, "failed RES_QP, 0x%llx\n",
1478 if (r
->com
.state
!= RES_QP_MAPPED
)
1486 r
->com
.from_state
= r
->com
.state
;
1487 r
->com
.to_state
= state
;
1488 r
->com
.state
= RES_QP_BUSY
;
1494 spin_unlock_irq(mlx4_tlock(dev
));
1499 static int mr_res_start_move_to(struct mlx4_dev
*dev
, int slave
, int index
,
1500 enum res_mpt_states state
, struct res_mpt
**mpt
)
1502 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1503 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1507 spin_lock_irq(mlx4_tlock(dev
));
1508 r
= res_tracker_lookup(&tracker
->res_tree
[RES_MPT
], index
);
1511 else if (r
->com
.owner
!= slave
)
1519 case RES_MPT_RESERVED
:
1520 if (r
->com
.state
!= RES_MPT_MAPPED
)
1524 case RES_MPT_MAPPED
:
1525 if (r
->com
.state
!= RES_MPT_RESERVED
&&
1526 r
->com
.state
!= RES_MPT_HW
)
1531 if (r
->com
.state
!= RES_MPT_MAPPED
)
1539 r
->com
.from_state
= r
->com
.state
;
1540 r
->com
.to_state
= state
;
1541 r
->com
.state
= RES_MPT_BUSY
;
1547 spin_unlock_irq(mlx4_tlock(dev
));
1552 static int eq_res_start_move_to(struct mlx4_dev
*dev
, int slave
, int index
,
1553 enum res_eq_states state
, struct res_eq
**eq
)
1555 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1556 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1560 spin_lock_irq(mlx4_tlock(dev
));
1561 r
= res_tracker_lookup(&tracker
->res_tree
[RES_EQ
], index
);
1564 else if (r
->com
.owner
!= slave
)
1572 case RES_EQ_RESERVED
:
1573 if (r
->com
.state
!= RES_EQ_HW
)
1578 if (r
->com
.state
!= RES_EQ_RESERVED
)
1587 r
->com
.from_state
= r
->com
.state
;
1588 r
->com
.to_state
= state
;
1589 r
->com
.state
= RES_EQ_BUSY
;
1595 spin_unlock_irq(mlx4_tlock(dev
));
1600 static int cq_res_start_move_to(struct mlx4_dev
*dev
, int slave
, int cqn
,
1601 enum res_cq_states state
, struct res_cq
**cq
)
1603 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1604 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1608 spin_lock_irq(mlx4_tlock(dev
));
1609 r
= res_tracker_lookup(&tracker
->res_tree
[RES_CQ
], cqn
);
1612 } else if (r
->com
.owner
!= slave
) {
1614 } else if (state
== RES_CQ_ALLOCATED
) {
1615 if (r
->com
.state
!= RES_CQ_HW
)
1617 else if (atomic_read(&r
->ref_count
))
1621 } else if (state
!= RES_CQ_HW
|| r
->com
.state
!= RES_CQ_ALLOCATED
) {
1628 r
->com
.from_state
= r
->com
.state
;
1629 r
->com
.to_state
= state
;
1630 r
->com
.state
= RES_CQ_BUSY
;
1635 spin_unlock_irq(mlx4_tlock(dev
));
1640 static int srq_res_start_move_to(struct mlx4_dev
*dev
, int slave
, int index
,
1641 enum res_srq_states state
, struct res_srq
**srq
)
1643 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1644 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1648 spin_lock_irq(mlx4_tlock(dev
));
1649 r
= res_tracker_lookup(&tracker
->res_tree
[RES_SRQ
], index
);
1652 } else if (r
->com
.owner
!= slave
) {
1654 } else if (state
== RES_SRQ_ALLOCATED
) {
1655 if (r
->com
.state
!= RES_SRQ_HW
)
1657 else if (atomic_read(&r
->ref_count
))
1659 } else if (state
!= RES_SRQ_HW
|| r
->com
.state
!= RES_SRQ_ALLOCATED
) {
1664 r
->com
.from_state
= r
->com
.state
;
1665 r
->com
.to_state
= state
;
1666 r
->com
.state
= RES_SRQ_BUSY
;
1671 spin_unlock_irq(mlx4_tlock(dev
));
1676 static void res_abort_move(struct mlx4_dev
*dev
, int slave
,
1677 enum mlx4_resource type
, int id
)
1679 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1680 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1681 struct res_common
*r
;
1683 spin_lock_irq(mlx4_tlock(dev
));
1684 r
= res_tracker_lookup(&tracker
->res_tree
[type
], id
);
1685 if (r
&& (r
->owner
== slave
))
1686 r
->state
= r
->from_state
;
1687 spin_unlock_irq(mlx4_tlock(dev
));
1690 static void res_end_move(struct mlx4_dev
*dev
, int slave
,
1691 enum mlx4_resource type
, int id
)
1693 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1694 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1695 struct res_common
*r
;
1697 spin_lock_irq(mlx4_tlock(dev
));
1698 r
= res_tracker_lookup(&tracker
->res_tree
[type
], id
);
1699 if (r
&& (r
->owner
== slave
))
1700 r
->state
= r
->to_state
;
1701 spin_unlock_irq(mlx4_tlock(dev
));
1704 static int valid_reserved(struct mlx4_dev
*dev
, int slave
, int qpn
)
1706 return mlx4_is_qp_reserved(dev
, qpn
) &&
1707 (mlx4_is_master(dev
) || mlx4_is_guest_proxy(dev
, slave
, qpn
));
1710 static int fw_reserved(struct mlx4_dev
*dev
, int qpn
)
1712 return qpn
< dev
->caps
.reserved_qps_cnt
[MLX4_QP_REGION_FW
];
1715 static int qp_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
1716 u64 in_param
, u64
*out_param
)
1726 case RES_OP_RESERVE
:
1727 count
= get_param_l(&in_param
) & 0xffffff;
1728 /* Turn off all unsupported QP allocation flags that the
1729 * slave tries to set.
1731 flags
= (get_param_l(&in_param
) >> 24) & dev
->caps
.alloc_res_qp_mask
;
1732 align
= get_param_h(&in_param
);
1733 err
= mlx4_grant_resource(dev
, slave
, RES_QP
, count
, 0);
1737 err
= __mlx4_qp_reserve_range(dev
, count
, align
, &base
, flags
);
1739 mlx4_release_resource(dev
, slave
, RES_QP
, count
, 0);
1743 err
= add_res_range(dev
, slave
, base
, count
, RES_QP
, 0);
1745 mlx4_release_resource(dev
, slave
, RES_QP
, count
, 0);
1746 __mlx4_qp_release_range(dev
, base
, count
);
1749 set_param_l(out_param
, base
);
1751 case RES_OP_MAP_ICM
:
1752 qpn
= get_param_l(&in_param
) & 0x7fffff;
1753 if (valid_reserved(dev
, slave
, qpn
)) {
1754 err
= add_res_range(dev
, slave
, qpn
, 1, RES_QP
, 0);
1759 err
= qp_res_start_move_to(dev
, slave
, qpn
, RES_QP_MAPPED
,
1764 if (!fw_reserved(dev
, qpn
)) {
1765 err
= __mlx4_qp_alloc_icm(dev
, qpn
, GFP_KERNEL
);
1767 res_abort_move(dev
, slave
, RES_QP
, qpn
);
1772 res_end_move(dev
, slave
, RES_QP
, qpn
);
1782 static int mtt_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
1783 u64 in_param
, u64
*out_param
)
1789 if (op
!= RES_OP_RESERVE_AND_MAP
)
1792 order
= get_param_l(&in_param
);
1794 err
= mlx4_grant_resource(dev
, slave
, RES_MTT
, 1 << order
, 0);
1798 base
= __mlx4_alloc_mtt_range(dev
, order
);
1800 mlx4_release_resource(dev
, slave
, RES_MTT
, 1 << order
, 0);
1804 err
= add_res_range(dev
, slave
, base
, 1, RES_MTT
, order
);
1806 mlx4_release_resource(dev
, slave
, RES_MTT
, 1 << order
, 0);
1807 __mlx4_free_mtt_range(dev
, base
, order
);
1809 set_param_l(out_param
, base
);
1815 static int mpt_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
1816 u64 in_param
, u64
*out_param
)
1821 struct res_mpt
*mpt
;
1824 case RES_OP_RESERVE
:
1825 err
= mlx4_grant_resource(dev
, slave
, RES_MPT
, 1, 0);
1829 index
= __mlx4_mpt_reserve(dev
);
1831 mlx4_release_resource(dev
, slave
, RES_MPT
, 1, 0);
1834 id
= index
& mpt_mask(dev
);
1836 err
= add_res_range(dev
, slave
, id
, 1, RES_MPT
, index
);
1838 mlx4_release_resource(dev
, slave
, RES_MPT
, 1, 0);
1839 __mlx4_mpt_release(dev
, index
);
1842 set_param_l(out_param
, index
);
1844 case RES_OP_MAP_ICM
:
1845 index
= get_param_l(&in_param
);
1846 id
= index
& mpt_mask(dev
);
1847 err
= mr_res_start_move_to(dev
, slave
, id
,
1848 RES_MPT_MAPPED
, &mpt
);
1852 err
= __mlx4_mpt_alloc_icm(dev
, mpt
->key
, GFP_KERNEL
);
1854 res_abort_move(dev
, slave
, RES_MPT
, id
);
1858 res_end_move(dev
, slave
, RES_MPT
, id
);
1864 static int cq_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
1865 u64 in_param
, u64
*out_param
)
1871 case RES_OP_RESERVE_AND_MAP
:
1872 err
= mlx4_grant_resource(dev
, slave
, RES_CQ
, 1, 0);
1876 err
= __mlx4_cq_alloc_icm(dev
, &cqn
);
1878 mlx4_release_resource(dev
, slave
, RES_CQ
, 1, 0);
1882 err
= add_res_range(dev
, slave
, cqn
, 1, RES_CQ
, 0);
1884 mlx4_release_resource(dev
, slave
, RES_CQ
, 1, 0);
1885 __mlx4_cq_free_icm(dev
, cqn
);
1889 set_param_l(out_param
, cqn
);
1899 static int srq_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
1900 u64 in_param
, u64
*out_param
)
1906 case RES_OP_RESERVE_AND_MAP
:
1907 err
= mlx4_grant_resource(dev
, slave
, RES_SRQ
, 1, 0);
1911 err
= __mlx4_srq_alloc_icm(dev
, &srqn
);
1913 mlx4_release_resource(dev
, slave
, RES_SRQ
, 1, 0);
1917 err
= add_res_range(dev
, slave
, srqn
, 1, RES_SRQ
, 0);
1919 mlx4_release_resource(dev
, slave
, RES_SRQ
, 1, 0);
1920 __mlx4_srq_free_icm(dev
, srqn
);
1924 set_param_l(out_param
, srqn
);
1934 static int mac_find_smac_ix_in_slave(struct mlx4_dev
*dev
, int slave
, int port
,
1935 u8 smac_index
, u64
*mac
)
1937 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1938 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1939 struct list_head
*mac_list
=
1940 &tracker
->slave_list
[slave
].res_list
[RES_MAC
];
1941 struct mac_res
*res
, *tmp
;
1943 list_for_each_entry_safe(res
, tmp
, mac_list
, list
) {
1944 if (res
->smac_index
== smac_index
&& res
->port
== (u8
) port
) {
1952 static int mac_add_to_slave(struct mlx4_dev
*dev
, int slave
, u64 mac
, int port
, u8 smac_index
)
1954 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1955 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1956 struct list_head
*mac_list
=
1957 &tracker
->slave_list
[slave
].res_list
[RES_MAC
];
1958 struct mac_res
*res
, *tmp
;
1960 list_for_each_entry_safe(res
, tmp
, mac_list
, list
) {
1961 if (res
->mac
== mac
&& res
->port
== (u8
) port
) {
1962 /* mac found. update ref count */
1968 if (mlx4_grant_resource(dev
, slave
, RES_MAC
, 1, port
))
1970 res
= kzalloc(sizeof *res
, GFP_KERNEL
);
1972 mlx4_release_resource(dev
, slave
, RES_MAC
, 1, port
);
1976 res
->port
= (u8
) port
;
1977 res
->smac_index
= smac_index
;
1979 list_add_tail(&res
->list
,
1980 &tracker
->slave_list
[slave
].res_list
[RES_MAC
]);
1984 static void mac_del_from_slave(struct mlx4_dev
*dev
, int slave
, u64 mac
,
1987 struct mlx4_priv
*priv
= mlx4_priv(dev
);
1988 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
1989 struct list_head
*mac_list
=
1990 &tracker
->slave_list
[slave
].res_list
[RES_MAC
];
1991 struct mac_res
*res
, *tmp
;
1993 list_for_each_entry_safe(res
, tmp
, mac_list
, list
) {
1994 if (res
->mac
== mac
&& res
->port
== (u8
) port
) {
1995 if (!--res
->ref_count
) {
1996 list_del(&res
->list
);
1997 mlx4_release_resource(dev
, slave
, RES_MAC
, 1, port
);
2005 static void rem_slave_macs(struct mlx4_dev
*dev
, int slave
)
2007 struct mlx4_priv
*priv
= mlx4_priv(dev
);
2008 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
2009 struct list_head
*mac_list
=
2010 &tracker
->slave_list
[slave
].res_list
[RES_MAC
];
2011 struct mac_res
*res
, *tmp
;
2014 list_for_each_entry_safe(res
, tmp
, mac_list
, list
) {
2015 list_del(&res
->list
);
2016 /* dereference the mac the num times the slave referenced it */
2017 for (i
= 0; i
< res
->ref_count
; i
++)
2018 __mlx4_unregister_mac(dev
, res
->port
, res
->mac
);
2019 mlx4_release_resource(dev
, slave
, RES_MAC
, 1, res
->port
);
2024 static int mac_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2025 u64 in_param
, u64
*out_param
, int in_port
)
2032 if (op
!= RES_OP_RESERVE_AND_MAP
)
2035 port
= !in_port
? get_param_l(out_param
) : in_port
;
2036 port
= mlx4_slave_convert_port(
2043 err
= __mlx4_register_mac(dev
, port
, mac
);
2046 set_param_l(out_param
, err
);
2051 err
= mac_add_to_slave(dev
, slave
, mac
, port
, smac_index
);
2053 __mlx4_unregister_mac(dev
, port
, mac
);
2058 static int vlan_add_to_slave(struct mlx4_dev
*dev
, int slave
, u16 vlan
,
2059 int port
, int vlan_index
)
2061 struct mlx4_priv
*priv
= mlx4_priv(dev
);
2062 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
2063 struct list_head
*vlan_list
=
2064 &tracker
->slave_list
[slave
].res_list
[RES_VLAN
];
2065 struct vlan_res
*res
, *tmp
;
2067 list_for_each_entry_safe(res
, tmp
, vlan_list
, list
) {
2068 if (res
->vlan
== vlan
&& res
->port
== (u8
) port
) {
2069 /* vlan found. update ref count */
2075 if (mlx4_grant_resource(dev
, slave
, RES_VLAN
, 1, port
))
2077 res
= kzalloc(sizeof(*res
), GFP_KERNEL
);
2079 mlx4_release_resource(dev
, slave
, RES_VLAN
, 1, port
);
2083 res
->port
= (u8
) port
;
2084 res
->vlan_index
= vlan_index
;
2086 list_add_tail(&res
->list
,
2087 &tracker
->slave_list
[slave
].res_list
[RES_VLAN
]);
2092 static void vlan_del_from_slave(struct mlx4_dev
*dev
, int slave
, u16 vlan
,
2095 struct mlx4_priv
*priv
= mlx4_priv(dev
);
2096 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
2097 struct list_head
*vlan_list
=
2098 &tracker
->slave_list
[slave
].res_list
[RES_VLAN
];
2099 struct vlan_res
*res
, *tmp
;
2101 list_for_each_entry_safe(res
, tmp
, vlan_list
, list
) {
2102 if (res
->vlan
== vlan
&& res
->port
== (u8
) port
) {
2103 if (!--res
->ref_count
) {
2104 list_del(&res
->list
);
2105 mlx4_release_resource(dev
, slave
, RES_VLAN
,
2114 static void rem_slave_vlans(struct mlx4_dev
*dev
, int slave
)
2116 struct mlx4_priv
*priv
= mlx4_priv(dev
);
2117 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
2118 struct list_head
*vlan_list
=
2119 &tracker
->slave_list
[slave
].res_list
[RES_VLAN
];
2120 struct vlan_res
*res
, *tmp
;
2123 list_for_each_entry_safe(res
, tmp
, vlan_list
, list
) {
2124 list_del(&res
->list
);
2125 /* dereference the vlan the num times the slave referenced it */
2126 for (i
= 0; i
< res
->ref_count
; i
++)
2127 __mlx4_unregister_vlan(dev
, res
->port
, res
->vlan
);
2128 mlx4_release_resource(dev
, slave
, RES_VLAN
, 1, res
->port
);
2133 static int vlan_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2134 u64 in_param
, u64
*out_param
, int in_port
)
2136 struct mlx4_priv
*priv
= mlx4_priv(dev
);
2137 struct mlx4_slave_state
*slave_state
= priv
->mfunc
.master
.slave_state
;
2143 port
= !in_port
? get_param_l(out_param
) : in_port
;
2145 if (!port
|| op
!= RES_OP_RESERVE_AND_MAP
)
2148 port
= mlx4_slave_convert_port(
2153 /* upstream kernels had NOP for reg/unreg vlan. Continue this. */
2154 if (!in_port
&& port
> 0 && port
<= dev
->caps
.num_ports
) {
2155 slave_state
[slave
].old_vlan_api
= true;
2159 vlan
= (u16
) in_param
;
2161 err
= __mlx4_register_vlan(dev
, port
, vlan
, &vlan_index
);
2163 set_param_l(out_param
, (u32
) vlan_index
);
2164 err
= vlan_add_to_slave(dev
, slave
, vlan
, port
, vlan_index
);
2166 __mlx4_unregister_vlan(dev
, port
, vlan
);
2171 static int counter_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2172 u64 in_param
, u64
*out_param
, int port
)
2177 if (op
!= RES_OP_RESERVE
)
2180 err
= mlx4_grant_resource(dev
, slave
, RES_COUNTER
, 1, 0);
2184 err
= __mlx4_counter_alloc(dev
, &index
);
2186 mlx4_release_resource(dev
, slave
, RES_COUNTER
, 1, 0);
2190 err
= add_res_range(dev
, slave
, index
, 1, RES_COUNTER
, port
);
2192 __mlx4_counter_free(dev
, index
);
2193 mlx4_release_resource(dev
, slave
, RES_COUNTER
, 1, 0);
2195 set_param_l(out_param
, index
);
2201 static int xrcdn_alloc_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2202 u64 in_param
, u64
*out_param
)
2207 if (op
!= RES_OP_RESERVE
)
2210 err
= __mlx4_xrcd_alloc(dev
, &xrcdn
);
2214 err
= add_res_range(dev
, slave
, xrcdn
, 1, RES_XRCD
, 0);
2216 __mlx4_xrcd_free(dev
, xrcdn
);
2218 set_param_l(out_param
, xrcdn
);
2223 int mlx4_ALLOC_RES_wrapper(struct mlx4_dev
*dev
, int slave
,
2224 struct mlx4_vhcr
*vhcr
,
2225 struct mlx4_cmd_mailbox
*inbox
,
2226 struct mlx4_cmd_mailbox
*outbox
,
2227 struct mlx4_cmd_info
*cmd
)
2230 int alop
= vhcr
->op_modifier
;
2232 switch (vhcr
->in_modifier
& 0xFF) {
2234 err
= qp_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2235 vhcr
->in_param
, &vhcr
->out_param
);
2239 err
= mtt_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2240 vhcr
->in_param
, &vhcr
->out_param
);
2244 err
= mpt_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2245 vhcr
->in_param
, &vhcr
->out_param
);
2249 err
= cq_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2250 vhcr
->in_param
, &vhcr
->out_param
);
2254 err
= srq_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2255 vhcr
->in_param
, &vhcr
->out_param
);
2259 err
= mac_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2260 vhcr
->in_param
, &vhcr
->out_param
,
2261 (vhcr
->in_modifier
>> 8) & 0xFF);
2265 err
= vlan_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2266 vhcr
->in_param
, &vhcr
->out_param
,
2267 (vhcr
->in_modifier
>> 8) & 0xFF);
2271 err
= counter_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2272 vhcr
->in_param
, &vhcr
->out_param
, 0);
2276 err
= xrcdn_alloc_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2277 vhcr
->in_param
, &vhcr
->out_param
);
2288 static int qp_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2297 case RES_OP_RESERVE
:
2298 base
= get_param_l(&in_param
) & 0x7fffff;
2299 count
= get_param_h(&in_param
);
2300 err
= rem_res_range(dev
, slave
, base
, count
, RES_QP
, 0);
2303 mlx4_release_resource(dev
, slave
, RES_QP
, count
, 0);
2304 __mlx4_qp_release_range(dev
, base
, count
);
2306 case RES_OP_MAP_ICM
:
2307 qpn
= get_param_l(&in_param
) & 0x7fffff;
2308 err
= qp_res_start_move_to(dev
, slave
, qpn
, RES_QP_RESERVED
,
2313 if (!fw_reserved(dev
, qpn
))
2314 __mlx4_qp_free_icm(dev
, qpn
);
2316 res_end_move(dev
, slave
, RES_QP
, qpn
);
2318 if (valid_reserved(dev
, slave
, qpn
))
2319 err
= rem_res_range(dev
, slave
, qpn
, 1, RES_QP
, 0);
2328 static int mtt_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2329 u64 in_param
, u64
*out_param
)
2335 if (op
!= RES_OP_RESERVE_AND_MAP
)
2338 base
= get_param_l(&in_param
);
2339 order
= get_param_h(&in_param
);
2340 err
= rem_res_range(dev
, slave
, base
, 1, RES_MTT
, order
);
2342 mlx4_release_resource(dev
, slave
, RES_MTT
, 1 << order
, 0);
2343 __mlx4_free_mtt_range(dev
, base
, order
);
2348 static int mpt_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2354 struct res_mpt
*mpt
;
2357 case RES_OP_RESERVE
:
2358 index
= get_param_l(&in_param
);
2359 id
= index
& mpt_mask(dev
);
2360 err
= get_res(dev
, slave
, id
, RES_MPT
, &mpt
);
2364 put_res(dev
, slave
, id
, RES_MPT
);
2366 err
= rem_res_range(dev
, slave
, id
, 1, RES_MPT
, 0);
2369 mlx4_release_resource(dev
, slave
, RES_MPT
, 1, 0);
2370 __mlx4_mpt_release(dev
, index
);
2372 case RES_OP_MAP_ICM
:
2373 index
= get_param_l(&in_param
);
2374 id
= index
& mpt_mask(dev
);
2375 err
= mr_res_start_move_to(dev
, slave
, id
,
2376 RES_MPT_RESERVED
, &mpt
);
2380 __mlx4_mpt_free_icm(dev
, mpt
->key
);
2381 res_end_move(dev
, slave
, RES_MPT
, id
);
2391 static int cq_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2392 u64 in_param
, u64
*out_param
)
2398 case RES_OP_RESERVE_AND_MAP
:
2399 cqn
= get_param_l(&in_param
);
2400 err
= rem_res_range(dev
, slave
, cqn
, 1, RES_CQ
, 0);
2404 mlx4_release_resource(dev
, slave
, RES_CQ
, 1, 0);
2405 __mlx4_cq_free_icm(dev
, cqn
);
2416 static int srq_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2417 u64 in_param
, u64
*out_param
)
2423 case RES_OP_RESERVE_AND_MAP
:
2424 srqn
= get_param_l(&in_param
);
2425 err
= rem_res_range(dev
, slave
, srqn
, 1, RES_SRQ
, 0);
2429 mlx4_release_resource(dev
, slave
, RES_SRQ
, 1, 0);
2430 __mlx4_srq_free_icm(dev
, srqn
);
2441 static int mac_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2442 u64 in_param
, u64
*out_param
, int in_port
)
2448 case RES_OP_RESERVE_AND_MAP
:
2449 port
= !in_port
? get_param_l(out_param
) : in_port
;
2450 port
= mlx4_slave_convert_port(
2455 mac_del_from_slave(dev
, slave
, in_param
, port
);
2456 __mlx4_unregister_mac(dev
, port
, in_param
);
2467 static int vlan_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2468 u64 in_param
, u64
*out_param
, int port
)
2470 struct mlx4_priv
*priv
= mlx4_priv(dev
);
2471 struct mlx4_slave_state
*slave_state
= priv
->mfunc
.master
.slave_state
;
2474 port
= mlx4_slave_convert_port(
2480 case RES_OP_RESERVE_AND_MAP
:
2481 if (slave_state
[slave
].old_vlan_api
)
2485 vlan_del_from_slave(dev
, slave
, in_param
, port
);
2486 __mlx4_unregister_vlan(dev
, port
, in_param
);
2496 static int counter_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2497 u64 in_param
, u64
*out_param
)
2502 if (op
!= RES_OP_RESERVE
)
2505 index
= get_param_l(&in_param
);
2506 if (index
== MLX4_SINK_COUNTER_INDEX(dev
))
2509 err
= rem_res_range(dev
, slave
, index
, 1, RES_COUNTER
, 0);
2513 __mlx4_counter_free(dev
, index
);
2514 mlx4_release_resource(dev
, slave
, RES_COUNTER
, 1, 0);
2519 static int xrcdn_free_res(struct mlx4_dev
*dev
, int slave
, int op
, int cmd
,
2520 u64 in_param
, u64
*out_param
)
2525 if (op
!= RES_OP_RESERVE
)
2528 xrcdn
= get_param_l(&in_param
);
2529 err
= rem_res_range(dev
, slave
, xrcdn
, 1, RES_XRCD
, 0);
2533 __mlx4_xrcd_free(dev
, xrcdn
);
2538 int mlx4_FREE_RES_wrapper(struct mlx4_dev
*dev
, int slave
,
2539 struct mlx4_vhcr
*vhcr
,
2540 struct mlx4_cmd_mailbox
*inbox
,
2541 struct mlx4_cmd_mailbox
*outbox
,
2542 struct mlx4_cmd_info
*cmd
)
2545 int alop
= vhcr
->op_modifier
;
2547 switch (vhcr
->in_modifier
& 0xFF) {
2549 err
= qp_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2554 err
= mtt_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2555 vhcr
->in_param
, &vhcr
->out_param
);
2559 err
= mpt_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2564 err
= cq_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2565 vhcr
->in_param
, &vhcr
->out_param
);
2569 err
= srq_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2570 vhcr
->in_param
, &vhcr
->out_param
);
2574 err
= mac_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2575 vhcr
->in_param
, &vhcr
->out_param
,
2576 (vhcr
->in_modifier
>> 8) & 0xFF);
2580 err
= vlan_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2581 vhcr
->in_param
, &vhcr
->out_param
,
2582 (vhcr
->in_modifier
>> 8) & 0xFF);
2586 err
= counter_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2587 vhcr
->in_param
, &vhcr
->out_param
);
2591 err
= xrcdn_free_res(dev
, slave
, vhcr
->op_modifier
, alop
,
2592 vhcr
->in_param
, &vhcr
->out_param
);
2600 /* ugly but other choices are uglier */
2601 static int mr_phys_mpt(struct mlx4_mpt_entry
*mpt
)
2603 return (be32_to_cpu(mpt
->flags
) >> 9) & 1;
2606 static int mr_get_mtt_addr(struct mlx4_mpt_entry
*mpt
)
2608 return (int)be64_to_cpu(mpt
->mtt_addr
) & 0xfffffff8;
2611 static int mr_get_mtt_size(struct mlx4_mpt_entry
*mpt
)
2613 return be32_to_cpu(mpt
->mtt_sz
);
2616 static u32
mr_get_pd(struct mlx4_mpt_entry
*mpt
)
2618 return be32_to_cpu(mpt
->pd_flags
) & 0x00ffffff;
2621 static int mr_is_fmr(struct mlx4_mpt_entry
*mpt
)
2623 return be32_to_cpu(mpt
->pd_flags
) & MLX4_MPT_PD_FLAG_FAST_REG
;
2626 static int mr_is_bind_enabled(struct mlx4_mpt_entry
*mpt
)
2628 return be32_to_cpu(mpt
->flags
) & MLX4_MPT_FLAG_BIND_ENABLE
;
2631 static int mr_is_region(struct mlx4_mpt_entry
*mpt
)
2633 return be32_to_cpu(mpt
->flags
) & MLX4_MPT_FLAG_REGION
;
2636 static int qp_get_mtt_addr(struct mlx4_qp_context
*qpc
)
2638 return be32_to_cpu(qpc
->mtt_base_addr_l
) & 0xfffffff8;
2641 static int srq_get_mtt_addr(struct mlx4_srq_context
*srqc
)
2643 return be32_to_cpu(srqc
->mtt_base_addr_l
) & 0xfffffff8;
2646 static int qp_get_mtt_size(struct mlx4_qp_context
*qpc
)
2648 int page_shift
= (qpc
->log_page_size
& 0x3f) + 12;
2649 int log_sq_size
= (qpc
->sq_size_stride
>> 3) & 0xf;
2650 int log_sq_sride
= qpc
->sq_size_stride
& 7;
2651 int log_rq_size
= (qpc
->rq_size_stride
>> 3) & 0xf;
2652 int log_rq_stride
= qpc
->rq_size_stride
& 7;
2653 int srq
= (be32_to_cpu(qpc
->srqn
) >> 24) & 1;
2654 int rss
= (be32_to_cpu(qpc
->flags
) >> 13) & 1;
2655 u32 ts
= (be32_to_cpu(qpc
->flags
) >> 16) & 0xff;
2656 int xrc
= (ts
== MLX4_QP_ST_XRC
) ? 1 : 0;
2661 int page_offset
= (be32_to_cpu(qpc
->params2
) >> 6) & 0x3f;
2663 sq_size
= 1 << (log_sq_size
+ log_sq_sride
+ 4);
2664 rq_size
= (srq
|rss
|xrc
) ? 0 : (1 << (log_rq_size
+ log_rq_stride
+ 4));
2665 total_mem
= sq_size
+ rq_size
;
2667 roundup_pow_of_two((total_mem
+ (page_offset
<< 6)) >>
2673 static int check_mtt_range(struct mlx4_dev
*dev
, int slave
, int start
,
2674 int size
, struct res_mtt
*mtt
)
2676 int res_start
= mtt
->com
.res_id
;
2677 int res_size
= (1 << mtt
->order
);
2679 if (start
< res_start
|| start
+ size
> res_start
+ res_size
)
2684 int mlx4_SW2HW_MPT_wrapper(struct mlx4_dev
*dev
, int slave
,
2685 struct mlx4_vhcr
*vhcr
,
2686 struct mlx4_cmd_mailbox
*inbox
,
2687 struct mlx4_cmd_mailbox
*outbox
,
2688 struct mlx4_cmd_info
*cmd
)
2691 int index
= vhcr
->in_modifier
;
2692 struct res_mtt
*mtt
;
2693 struct res_mpt
*mpt
;
2694 int mtt_base
= mr_get_mtt_addr(inbox
->buf
) / dev
->caps
.mtt_entry_sz
;
2700 id
= index
& mpt_mask(dev
);
2701 err
= mr_res_start_move_to(dev
, slave
, id
, RES_MPT_HW
, &mpt
);
2705 /* Disable memory windows for VFs. */
2706 if (!mr_is_region(inbox
->buf
)) {
2711 /* Make sure that the PD bits related to the slave id are zeros. */
2712 pd
= mr_get_pd(inbox
->buf
);
2713 pd_slave
= (pd
>> 17) & 0x7f;
2714 if (pd_slave
!= 0 && --pd_slave
!= slave
) {
2719 if (mr_is_fmr(inbox
->buf
)) {
2720 /* FMR and Bind Enable are forbidden in slave devices. */
2721 if (mr_is_bind_enabled(inbox
->buf
)) {
2725 /* FMR and Memory Windows are also forbidden. */
2726 if (!mr_is_region(inbox
->buf
)) {
2732 phys
= mr_phys_mpt(inbox
->buf
);
2734 err
= get_res(dev
, slave
, mtt_base
, RES_MTT
, &mtt
);
2738 err
= check_mtt_range(dev
, slave
, mtt_base
,
2739 mr_get_mtt_size(inbox
->buf
), mtt
);
2746 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
2751 atomic_inc(&mtt
->ref_count
);
2752 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
2755 res_end_move(dev
, slave
, RES_MPT
, id
);
2760 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
2762 res_abort_move(dev
, slave
, RES_MPT
, id
);
2767 int mlx4_HW2SW_MPT_wrapper(struct mlx4_dev
*dev
, int slave
,
2768 struct mlx4_vhcr
*vhcr
,
2769 struct mlx4_cmd_mailbox
*inbox
,
2770 struct mlx4_cmd_mailbox
*outbox
,
2771 struct mlx4_cmd_info
*cmd
)
2774 int index
= vhcr
->in_modifier
;
2775 struct res_mpt
*mpt
;
2778 id
= index
& mpt_mask(dev
);
2779 err
= mr_res_start_move_to(dev
, slave
, id
, RES_MPT_MAPPED
, &mpt
);
2783 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
2788 atomic_dec(&mpt
->mtt
->ref_count
);
2790 res_end_move(dev
, slave
, RES_MPT
, id
);
2794 res_abort_move(dev
, slave
, RES_MPT
, id
);
2799 int mlx4_QUERY_MPT_wrapper(struct mlx4_dev
*dev
, int slave
,
2800 struct mlx4_vhcr
*vhcr
,
2801 struct mlx4_cmd_mailbox
*inbox
,
2802 struct mlx4_cmd_mailbox
*outbox
,
2803 struct mlx4_cmd_info
*cmd
)
2806 int index
= vhcr
->in_modifier
;
2807 struct res_mpt
*mpt
;
2810 id
= index
& mpt_mask(dev
);
2811 err
= get_res(dev
, slave
, id
, RES_MPT
, &mpt
);
2815 if (mpt
->com
.from_state
== RES_MPT_MAPPED
) {
2816 /* In order to allow rereg in SRIOV, we need to alter the MPT entry. To do
2817 * that, the VF must read the MPT. But since the MPT entry memory is not
2818 * in the VF's virtual memory space, it must use QUERY_MPT to obtain the
2819 * entry contents. To guarantee that the MPT cannot be changed, the driver
2820 * must perform HW2SW_MPT before this query and return the MPT entry to HW
2821 * ownership fofollowing the change. The change here allows the VF to
2822 * perform QUERY_MPT also when the entry is in SW ownership.
2824 struct mlx4_mpt_entry
*mpt_entry
= mlx4_table_find(
2825 &mlx4_priv(dev
)->mr_table
.dmpt_table
,
2828 if (NULL
== mpt_entry
|| NULL
== outbox
->buf
) {
2833 memcpy(outbox
->buf
, mpt_entry
, sizeof(*mpt_entry
));
2836 } else if (mpt
->com
.from_state
== RES_MPT_HW
) {
2837 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
2845 put_res(dev
, slave
, id
, RES_MPT
);
2849 static int qp_get_rcqn(struct mlx4_qp_context
*qpc
)
2851 return be32_to_cpu(qpc
->cqn_recv
) & 0xffffff;
2854 static int qp_get_scqn(struct mlx4_qp_context
*qpc
)
2856 return be32_to_cpu(qpc
->cqn_send
) & 0xffffff;
2859 static u32
qp_get_srqn(struct mlx4_qp_context
*qpc
)
2861 return be32_to_cpu(qpc
->srqn
) & 0x1ffffff;
2864 static void adjust_proxy_tun_qkey(struct mlx4_dev
*dev
, struct mlx4_vhcr
*vhcr
,
2865 struct mlx4_qp_context
*context
)
2867 u32 qpn
= vhcr
->in_modifier
& 0xffffff;
2870 if (mlx4_get_parav_qkey(dev
, qpn
, &qkey
))
2873 /* adjust qkey in qp context */
2874 context
->qkey
= cpu_to_be32(qkey
);
2877 static int adjust_qp_sched_queue(struct mlx4_dev
*dev
, int slave
,
2878 struct mlx4_qp_context
*qpc
,
2879 struct mlx4_cmd_mailbox
*inbox
);
2881 int mlx4_RST2INIT_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
2882 struct mlx4_vhcr
*vhcr
,
2883 struct mlx4_cmd_mailbox
*inbox
,
2884 struct mlx4_cmd_mailbox
*outbox
,
2885 struct mlx4_cmd_info
*cmd
)
2888 int qpn
= vhcr
->in_modifier
& 0x7fffff;
2889 struct res_mtt
*mtt
;
2891 struct mlx4_qp_context
*qpc
= inbox
->buf
+ 8;
2892 int mtt_base
= qp_get_mtt_addr(qpc
) / dev
->caps
.mtt_entry_sz
;
2893 int mtt_size
= qp_get_mtt_size(qpc
);
2896 int rcqn
= qp_get_rcqn(qpc
);
2897 int scqn
= qp_get_scqn(qpc
);
2898 u32 srqn
= qp_get_srqn(qpc
) & 0xffffff;
2899 int use_srq
= (qp_get_srqn(qpc
) >> 24) & 1;
2900 struct res_srq
*srq
;
2901 int local_qpn
= be32_to_cpu(qpc
->local_qpn
) & 0xffffff;
2903 err
= adjust_qp_sched_queue(dev
, slave
, qpc
, inbox
);
2907 err
= qp_res_start_move_to(dev
, slave
, qpn
, RES_QP_HW
, &qp
, 0);
2910 qp
->local_qpn
= local_qpn
;
2911 qp
->sched_queue
= 0;
2913 qp
->vlan_control
= 0;
2915 qp
->pri_path_fl
= 0;
2918 qp
->qpc_flags
= be32_to_cpu(qpc
->flags
);
2920 err
= get_res(dev
, slave
, mtt_base
, RES_MTT
, &mtt
);
2924 err
= check_mtt_range(dev
, slave
, mtt_base
, mtt_size
, mtt
);
2928 err
= get_res(dev
, slave
, rcqn
, RES_CQ
, &rcq
);
2933 err
= get_res(dev
, slave
, scqn
, RES_CQ
, &scq
);
2940 err
= get_res(dev
, slave
, srqn
, RES_SRQ
, &srq
);
2945 adjust_proxy_tun_qkey(dev
, vhcr
, qpc
);
2946 update_pkey_index(dev
, slave
, inbox
);
2947 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
2950 atomic_inc(&mtt
->ref_count
);
2952 atomic_inc(&rcq
->ref_count
);
2954 atomic_inc(&scq
->ref_count
);
2958 put_res(dev
, slave
, scqn
, RES_CQ
);
2961 atomic_inc(&srq
->ref_count
);
2962 put_res(dev
, slave
, srqn
, RES_SRQ
);
2965 put_res(dev
, slave
, rcqn
, RES_CQ
);
2966 put_res(dev
, slave
, mtt_base
, RES_MTT
);
2967 res_end_move(dev
, slave
, RES_QP
, qpn
);
2973 put_res(dev
, slave
, srqn
, RES_SRQ
);
2976 put_res(dev
, slave
, scqn
, RES_CQ
);
2978 put_res(dev
, slave
, rcqn
, RES_CQ
);
2980 put_res(dev
, slave
, mtt_base
, RES_MTT
);
2982 res_abort_move(dev
, slave
, RES_QP
, qpn
);
2987 static int eq_get_mtt_addr(struct mlx4_eq_context
*eqc
)
2989 return be32_to_cpu(eqc
->mtt_base_addr_l
) & 0xfffffff8;
2992 static int eq_get_mtt_size(struct mlx4_eq_context
*eqc
)
2994 int log_eq_size
= eqc
->log_eq_size
& 0x1f;
2995 int page_shift
= (eqc
->log_page_size
& 0x3f) + 12;
2997 if (log_eq_size
+ 5 < page_shift
)
3000 return 1 << (log_eq_size
+ 5 - page_shift
);
3003 static int cq_get_mtt_addr(struct mlx4_cq_context
*cqc
)
3005 return be32_to_cpu(cqc
->mtt_base_addr_l
) & 0xfffffff8;
3008 static int cq_get_mtt_size(struct mlx4_cq_context
*cqc
)
3010 int log_cq_size
= (be32_to_cpu(cqc
->logsize_usrpage
) >> 24) & 0x1f;
3011 int page_shift
= (cqc
->log_page_size
& 0x3f) + 12;
3013 if (log_cq_size
+ 5 < page_shift
)
3016 return 1 << (log_cq_size
+ 5 - page_shift
);
3019 int mlx4_SW2HW_EQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3020 struct mlx4_vhcr
*vhcr
,
3021 struct mlx4_cmd_mailbox
*inbox
,
3022 struct mlx4_cmd_mailbox
*outbox
,
3023 struct mlx4_cmd_info
*cmd
)
3026 int eqn
= vhcr
->in_modifier
;
3027 int res_id
= (slave
<< 10) | eqn
;
3028 struct mlx4_eq_context
*eqc
= inbox
->buf
;
3029 int mtt_base
= eq_get_mtt_addr(eqc
) / dev
->caps
.mtt_entry_sz
;
3030 int mtt_size
= eq_get_mtt_size(eqc
);
3032 struct res_mtt
*mtt
;
3034 err
= add_res_range(dev
, slave
, res_id
, 1, RES_EQ
, 0);
3037 err
= eq_res_start_move_to(dev
, slave
, res_id
, RES_EQ_HW
, &eq
);
3041 err
= get_res(dev
, slave
, mtt_base
, RES_MTT
, &mtt
);
3045 err
= check_mtt_range(dev
, slave
, mtt_base
, mtt_size
, mtt
);
3049 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3053 atomic_inc(&mtt
->ref_count
);
3055 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3056 res_end_move(dev
, slave
, RES_EQ
, res_id
);
3060 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3062 res_abort_move(dev
, slave
, RES_EQ
, res_id
);
3064 rem_res_range(dev
, slave
, res_id
, 1, RES_EQ
, 0);
3068 int mlx4_CONFIG_DEV_wrapper(struct mlx4_dev
*dev
, int slave
,
3069 struct mlx4_vhcr
*vhcr
,
3070 struct mlx4_cmd_mailbox
*inbox
,
3071 struct mlx4_cmd_mailbox
*outbox
,
3072 struct mlx4_cmd_info
*cmd
)
3075 u8 get
= vhcr
->op_modifier
;
3080 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3085 static int get_containing_mtt(struct mlx4_dev
*dev
, int slave
, int start
,
3086 int len
, struct res_mtt
**res
)
3088 struct mlx4_priv
*priv
= mlx4_priv(dev
);
3089 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
3090 struct res_mtt
*mtt
;
3093 spin_lock_irq(mlx4_tlock(dev
));
3094 list_for_each_entry(mtt
, &tracker
->slave_list
[slave
].res_list
[RES_MTT
],
3096 if (!check_mtt_range(dev
, slave
, start
, len
, mtt
)) {
3098 mtt
->com
.from_state
= mtt
->com
.state
;
3099 mtt
->com
.state
= RES_MTT_BUSY
;
3104 spin_unlock_irq(mlx4_tlock(dev
));
3109 static int verify_qp_parameters(struct mlx4_dev
*dev
,
3110 struct mlx4_vhcr
*vhcr
,
3111 struct mlx4_cmd_mailbox
*inbox
,
3112 enum qp_transition transition
, u8 slave
)
3116 struct mlx4_qp_context
*qp_ctx
;
3117 enum mlx4_qp_optpar optpar
;
3121 qp_ctx
= inbox
->buf
+ 8;
3122 qp_type
= (be32_to_cpu(qp_ctx
->flags
) >> 16) & 0xff;
3123 optpar
= be32_to_cpu(*(__be32
*) inbox
->buf
);
3125 if (slave
!= mlx4_master_func_num(dev
)) {
3126 qp_ctx
->params2
&= ~MLX4_QP_BIT_FPP
;
3127 /* setting QP rate-limit is disallowed for VFs */
3128 if (qp_ctx
->rate_limit_params
)
3134 case MLX4_QP_ST_XRC
:
3136 switch (transition
) {
3137 case QP_TRANS_INIT2RTR
:
3138 case QP_TRANS_RTR2RTS
:
3139 case QP_TRANS_RTS2RTS
:
3140 case QP_TRANS_SQD2SQD
:
3141 case QP_TRANS_SQD2RTS
:
3142 if (slave
!= mlx4_master_func_num(dev
))
3143 if (optpar
& MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH
) {
3144 port
= (qp_ctx
->pri_path
.sched_queue
>> 6 & 1) + 1;
3145 if (dev
->caps
.port_mask
[port
] != MLX4_PORT_TYPE_IB
)
3146 num_gids
= mlx4_get_slave_num_gids(dev
, slave
, port
);
3149 if (qp_ctx
->pri_path
.mgid_index
>= num_gids
)
3152 if (optpar
& MLX4_QP_OPTPAR_ALT_ADDR_PATH
) {
3153 port
= (qp_ctx
->alt_path
.sched_queue
>> 6 & 1) + 1;
3154 if (dev
->caps
.port_mask
[port
] != MLX4_PORT_TYPE_IB
)
3155 num_gids
= mlx4_get_slave_num_gids(dev
, slave
, port
);
3158 if (qp_ctx
->alt_path
.mgid_index
>= num_gids
)
3167 case MLX4_QP_ST_MLX
:
3168 qpn
= vhcr
->in_modifier
& 0x7fffff;
3169 port
= (qp_ctx
->pri_path
.sched_queue
>> 6 & 1) + 1;
3170 if (transition
== QP_TRANS_INIT2RTR
&&
3171 slave
!= mlx4_master_func_num(dev
) &&
3172 mlx4_is_qp_reserved(dev
, qpn
) &&
3173 !mlx4_vf_smi_enabled(dev
, slave
, port
)) {
3174 /* only enabled VFs may create MLX proxy QPs */
3175 mlx4_err(dev
, "%s: unprivileged slave %d attempting to create an MLX proxy special QP on port %d\n",
3176 __func__
, slave
, port
);
3188 int mlx4_WRITE_MTT_wrapper(struct mlx4_dev
*dev
, int slave
,
3189 struct mlx4_vhcr
*vhcr
,
3190 struct mlx4_cmd_mailbox
*inbox
,
3191 struct mlx4_cmd_mailbox
*outbox
,
3192 struct mlx4_cmd_info
*cmd
)
3194 struct mlx4_mtt mtt
;
3195 __be64
*page_list
= inbox
->buf
;
3196 u64
*pg_list
= (u64
*)page_list
;
3198 struct res_mtt
*rmtt
= NULL
;
3199 int start
= be64_to_cpu(page_list
[0]);
3200 int npages
= vhcr
->in_modifier
;
3203 err
= get_containing_mtt(dev
, slave
, start
, npages
, &rmtt
);
3207 /* Call the SW implementation of write_mtt:
3208 * - Prepare a dummy mtt struct
3209 * - Translate inbox contents to simple addresses in host endianness */
3210 mtt
.offset
= 0; /* TBD this is broken but I don't handle it since
3211 we don't really use it */
3214 for (i
= 0; i
< npages
; ++i
)
3215 pg_list
[i
+ 2] = (be64_to_cpu(page_list
[i
+ 2]) & ~1ULL);
3217 err
= __mlx4_write_mtt(dev
, &mtt
, be64_to_cpu(page_list
[0]), npages
,
3218 ((u64
*)page_list
+ 2));
3221 put_res(dev
, slave
, rmtt
->com
.res_id
, RES_MTT
);
3226 int mlx4_HW2SW_EQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3227 struct mlx4_vhcr
*vhcr
,
3228 struct mlx4_cmd_mailbox
*inbox
,
3229 struct mlx4_cmd_mailbox
*outbox
,
3230 struct mlx4_cmd_info
*cmd
)
3232 int eqn
= vhcr
->in_modifier
;
3233 int res_id
= eqn
| (slave
<< 10);
3237 err
= eq_res_start_move_to(dev
, slave
, res_id
, RES_EQ_RESERVED
, &eq
);
3241 err
= get_res(dev
, slave
, eq
->mtt
->com
.res_id
, RES_MTT
, NULL
);
3245 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3249 atomic_dec(&eq
->mtt
->ref_count
);
3250 put_res(dev
, slave
, eq
->mtt
->com
.res_id
, RES_MTT
);
3251 res_end_move(dev
, slave
, RES_EQ
, res_id
);
3252 rem_res_range(dev
, slave
, res_id
, 1, RES_EQ
, 0);
3257 put_res(dev
, slave
, eq
->mtt
->com
.res_id
, RES_MTT
);
3259 res_abort_move(dev
, slave
, RES_EQ
, res_id
);
3264 int mlx4_GEN_EQE(struct mlx4_dev
*dev
, int slave
, struct mlx4_eqe
*eqe
)
3266 struct mlx4_priv
*priv
= mlx4_priv(dev
);
3267 struct mlx4_slave_event_eq_info
*event_eq
;
3268 struct mlx4_cmd_mailbox
*mailbox
;
3269 u32 in_modifier
= 0;
3274 if (!priv
->mfunc
.master
.slave_state
)
3277 /* check for slave valid, slave not PF, and slave active */
3278 if (slave
< 0 || slave
> dev
->persist
->num_vfs
||
3279 slave
== dev
->caps
.function
||
3280 !priv
->mfunc
.master
.slave_state
[slave
].active
)
3283 event_eq
= &priv
->mfunc
.master
.slave_state
[slave
].event_eq
[eqe
->type
];
3285 /* Create the event only if the slave is registered */
3286 if (event_eq
->eqn
< 0)
3289 mutex_lock(&priv
->mfunc
.master
.gen_eqe_mutex
[slave
]);
3290 res_id
= (slave
<< 10) | event_eq
->eqn
;
3291 err
= get_res(dev
, slave
, res_id
, RES_EQ
, &req
);
3295 if (req
->com
.from_state
!= RES_EQ_HW
) {
3300 mailbox
= mlx4_alloc_cmd_mailbox(dev
);
3301 if (IS_ERR(mailbox
)) {
3302 err
= PTR_ERR(mailbox
);
3306 if (eqe
->type
== MLX4_EVENT_TYPE_CMD
) {
3308 eqe
->event
.cmd
.token
= cpu_to_be16(event_eq
->token
);
3311 memcpy(mailbox
->buf
, (u8
*) eqe
, 28);
3313 in_modifier
= (slave
& 0xff) | ((event_eq
->eqn
& 0x3ff) << 16);
3315 err
= mlx4_cmd(dev
, mailbox
->dma
, in_modifier
, 0,
3316 MLX4_CMD_GEN_EQE
, MLX4_CMD_TIME_CLASS_B
,
3319 put_res(dev
, slave
, res_id
, RES_EQ
);
3320 mutex_unlock(&priv
->mfunc
.master
.gen_eqe_mutex
[slave
]);
3321 mlx4_free_cmd_mailbox(dev
, mailbox
);
3325 put_res(dev
, slave
, res_id
, RES_EQ
);
3328 mutex_unlock(&priv
->mfunc
.master
.gen_eqe_mutex
[slave
]);
3332 int mlx4_QUERY_EQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3333 struct mlx4_vhcr
*vhcr
,
3334 struct mlx4_cmd_mailbox
*inbox
,
3335 struct mlx4_cmd_mailbox
*outbox
,
3336 struct mlx4_cmd_info
*cmd
)
3338 int eqn
= vhcr
->in_modifier
;
3339 int res_id
= eqn
| (slave
<< 10);
3343 err
= get_res(dev
, slave
, res_id
, RES_EQ
, &eq
);
3347 if (eq
->com
.from_state
!= RES_EQ_HW
) {
3352 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3355 put_res(dev
, slave
, res_id
, RES_EQ
);
3359 int mlx4_SW2HW_CQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3360 struct mlx4_vhcr
*vhcr
,
3361 struct mlx4_cmd_mailbox
*inbox
,
3362 struct mlx4_cmd_mailbox
*outbox
,
3363 struct mlx4_cmd_info
*cmd
)
3366 int cqn
= vhcr
->in_modifier
;
3367 struct mlx4_cq_context
*cqc
= inbox
->buf
;
3368 int mtt_base
= cq_get_mtt_addr(cqc
) / dev
->caps
.mtt_entry_sz
;
3369 struct res_cq
*cq
= NULL
;
3370 struct res_mtt
*mtt
;
3372 err
= cq_res_start_move_to(dev
, slave
, cqn
, RES_CQ_HW
, &cq
);
3375 err
= get_res(dev
, slave
, mtt_base
, RES_MTT
, &mtt
);
3378 err
= check_mtt_range(dev
, slave
, mtt_base
, cq_get_mtt_size(cqc
), mtt
);
3381 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3384 atomic_inc(&mtt
->ref_count
);
3386 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3387 res_end_move(dev
, slave
, RES_CQ
, cqn
);
3391 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3393 res_abort_move(dev
, slave
, RES_CQ
, cqn
);
3397 int mlx4_HW2SW_CQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3398 struct mlx4_vhcr
*vhcr
,
3399 struct mlx4_cmd_mailbox
*inbox
,
3400 struct mlx4_cmd_mailbox
*outbox
,
3401 struct mlx4_cmd_info
*cmd
)
3404 int cqn
= vhcr
->in_modifier
;
3405 struct res_cq
*cq
= NULL
;
3407 err
= cq_res_start_move_to(dev
, slave
, cqn
, RES_CQ_ALLOCATED
, &cq
);
3410 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3413 atomic_dec(&cq
->mtt
->ref_count
);
3414 res_end_move(dev
, slave
, RES_CQ
, cqn
);
3418 res_abort_move(dev
, slave
, RES_CQ
, cqn
);
3422 int mlx4_QUERY_CQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3423 struct mlx4_vhcr
*vhcr
,
3424 struct mlx4_cmd_mailbox
*inbox
,
3425 struct mlx4_cmd_mailbox
*outbox
,
3426 struct mlx4_cmd_info
*cmd
)
3428 int cqn
= vhcr
->in_modifier
;
3432 err
= get_res(dev
, slave
, cqn
, RES_CQ
, &cq
);
3436 if (cq
->com
.from_state
!= RES_CQ_HW
)
3439 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3441 put_res(dev
, slave
, cqn
, RES_CQ
);
3446 static int handle_resize(struct mlx4_dev
*dev
, int slave
,
3447 struct mlx4_vhcr
*vhcr
,
3448 struct mlx4_cmd_mailbox
*inbox
,
3449 struct mlx4_cmd_mailbox
*outbox
,
3450 struct mlx4_cmd_info
*cmd
,
3454 struct res_mtt
*orig_mtt
;
3455 struct res_mtt
*mtt
;
3456 struct mlx4_cq_context
*cqc
= inbox
->buf
;
3457 int mtt_base
= cq_get_mtt_addr(cqc
) / dev
->caps
.mtt_entry_sz
;
3459 err
= get_res(dev
, slave
, cq
->mtt
->com
.res_id
, RES_MTT
, &orig_mtt
);
3463 if (orig_mtt
!= cq
->mtt
) {
3468 err
= get_res(dev
, slave
, mtt_base
, RES_MTT
, &mtt
);
3472 err
= check_mtt_range(dev
, slave
, mtt_base
, cq_get_mtt_size(cqc
), mtt
);
3475 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3478 atomic_dec(&orig_mtt
->ref_count
);
3479 put_res(dev
, slave
, orig_mtt
->com
.res_id
, RES_MTT
);
3480 atomic_inc(&mtt
->ref_count
);
3482 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3486 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3488 put_res(dev
, slave
, orig_mtt
->com
.res_id
, RES_MTT
);
3494 int mlx4_MODIFY_CQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3495 struct mlx4_vhcr
*vhcr
,
3496 struct mlx4_cmd_mailbox
*inbox
,
3497 struct mlx4_cmd_mailbox
*outbox
,
3498 struct mlx4_cmd_info
*cmd
)
3500 int cqn
= vhcr
->in_modifier
;
3504 err
= get_res(dev
, slave
, cqn
, RES_CQ
, &cq
);
3508 if (cq
->com
.from_state
!= RES_CQ_HW
)
3511 if (vhcr
->op_modifier
== 0) {
3512 err
= handle_resize(dev
, slave
, vhcr
, inbox
, outbox
, cmd
, cq
);
3516 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3518 put_res(dev
, slave
, cqn
, RES_CQ
);
3523 static int srq_get_mtt_size(struct mlx4_srq_context
*srqc
)
3525 int log_srq_size
= (be32_to_cpu(srqc
->state_logsize_srqn
) >> 24) & 0xf;
3526 int log_rq_stride
= srqc
->logstride
& 7;
3527 int page_shift
= (srqc
->log_page_size
& 0x3f) + 12;
3529 if (log_srq_size
+ log_rq_stride
+ 4 < page_shift
)
3532 return 1 << (log_srq_size
+ log_rq_stride
+ 4 - page_shift
);
3535 int mlx4_SW2HW_SRQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3536 struct mlx4_vhcr
*vhcr
,
3537 struct mlx4_cmd_mailbox
*inbox
,
3538 struct mlx4_cmd_mailbox
*outbox
,
3539 struct mlx4_cmd_info
*cmd
)
3542 int srqn
= vhcr
->in_modifier
;
3543 struct res_mtt
*mtt
;
3544 struct res_srq
*srq
= NULL
;
3545 struct mlx4_srq_context
*srqc
= inbox
->buf
;
3546 int mtt_base
= srq_get_mtt_addr(srqc
) / dev
->caps
.mtt_entry_sz
;
3548 if (srqn
!= (be32_to_cpu(srqc
->state_logsize_srqn
) & 0xffffff))
3551 err
= srq_res_start_move_to(dev
, slave
, srqn
, RES_SRQ_HW
, &srq
);
3554 err
= get_res(dev
, slave
, mtt_base
, RES_MTT
, &mtt
);
3557 err
= check_mtt_range(dev
, slave
, mtt_base
, srq_get_mtt_size(srqc
),
3562 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3566 atomic_inc(&mtt
->ref_count
);
3568 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3569 res_end_move(dev
, slave
, RES_SRQ
, srqn
);
3573 put_res(dev
, slave
, mtt
->com
.res_id
, RES_MTT
);
3575 res_abort_move(dev
, slave
, RES_SRQ
, srqn
);
3580 int mlx4_HW2SW_SRQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3581 struct mlx4_vhcr
*vhcr
,
3582 struct mlx4_cmd_mailbox
*inbox
,
3583 struct mlx4_cmd_mailbox
*outbox
,
3584 struct mlx4_cmd_info
*cmd
)
3587 int srqn
= vhcr
->in_modifier
;
3588 struct res_srq
*srq
= NULL
;
3590 err
= srq_res_start_move_to(dev
, slave
, srqn
, RES_SRQ_ALLOCATED
, &srq
);
3593 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3596 atomic_dec(&srq
->mtt
->ref_count
);
3598 atomic_dec(&srq
->cq
->ref_count
);
3599 res_end_move(dev
, slave
, RES_SRQ
, srqn
);
3604 res_abort_move(dev
, slave
, RES_SRQ
, srqn
);
3609 int mlx4_QUERY_SRQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3610 struct mlx4_vhcr
*vhcr
,
3611 struct mlx4_cmd_mailbox
*inbox
,
3612 struct mlx4_cmd_mailbox
*outbox
,
3613 struct mlx4_cmd_info
*cmd
)
3616 int srqn
= vhcr
->in_modifier
;
3617 struct res_srq
*srq
;
3619 err
= get_res(dev
, slave
, srqn
, RES_SRQ
, &srq
);
3622 if (srq
->com
.from_state
!= RES_SRQ_HW
) {
3626 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3628 put_res(dev
, slave
, srqn
, RES_SRQ
);
3632 int mlx4_ARM_SRQ_wrapper(struct mlx4_dev
*dev
, int slave
,
3633 struct mlx4_vhcr
*vhcr
,
3634 struct mlx4_cmd_mailbox
*inbox
,
3635 struct mlx4_cmd_mailbox
*outbox
,
3636 struct mlx4_cmd_info
*cmd
)
3639 int srqn
= vhcr
->in_modifier
;
3640 struct res_srq
*srq
;
3642 err
= get_res(dev
, slave
, srqn
, RES_SRQ
, &srq
);
3646 if (srq
->com
.from_state
!= RES_SRQ_HW
) {
3651 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3653 put_res(dev
, slave
, srqn
, RES_SRQ
);
3657 int mlx4_GEN_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3658 struct mlx4_vhcr
*vhcr
,
3659 struct mlx4_cmd_mailbox
*inbox
,
3660 struct mlx4_cmd_mailbox
*outbox
,
3661 struct mlx4_cmd_info
*cmd
)
3664 int qpn
= vhcr
->in_modifier
& 0x7fffff;
3667 err
= get_res(dev
, slave
, qpn
, RES_QP
, &qp
);
3670 if (qp
->com
.from_state
!= RES_QP_HW
) {
3675 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3677 put_res(dev
, slave
, qpn
, RES_QP
);
3681 int mlx4_INIT2INIT_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3682 struct mlx4_vhcr
*vhcr
,
3683 struct mlx4_cmd_mailbox
*inbox
,
3684 struct mlx4_cmd_mailbox
*outbox
,
3685 struct mlx4_cmd_info
*cmd
)
3687 struct mlx4_qp_context
*context
= inbox
->buf
+ 8;
3688 adjust_proxy_tun_qkey(dev
, vhcr
, context
);
3689 update_pkey_index(dev
, slave
, inbox
);
3690 return mlx4_GEN_QP_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3693 static int adjust_qp_sched_queue(struct mlx4_dev
*dev
, int slave
,
3694 struct mlx4_qp_context
*qpc
,
3695 struct mlx4_cmd_mailbox
*inbox
)
3697 enum mlx4_qp_optpar optpar
= be32_to_cpu(*(__be32
*)inbox
->buf
);
3699 int port
= mlx4_slave_convert_port(
3700 dev
, slave
, (qpc
->pri_path
.sched_queue
>> 6 & 1) + 1) - 1;
3705 pri_sched_queue
= (qpc
->pri_path
.sched_queue
& ~(1 << 6)) |
3708 if (optpar
& (MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH
| MLX4_QP_OPTPAR_SCHED_QUEUE
) ||
3709 qpc
->pri_path
.sched_queue
|| mlx4_is_eth(dev
, port
+ 1)) {
3710 qpc
->pri_path
.sched_queue
= pri_sched_queue
;
3713 if (optpar
& MLX4_QP_OPTPAR_ALT_ADDR_PATH
) {
3714 port
= mlx4_slave_convert_port(
3715 dev
, slave
, (qpc
->alt_path
.sched_queue
>> 6 & 1)
3719 qpc
->alt_path
.sched_queue
=
3720 (qpc
->alt_path
.sched_queue
& ~(1 << 6)) |
3726 static int roce_verify_mac(struct mlx4_dev
*dev
, int slave
,
3727 struct mlx4_qp_context
*qpc
,
3728 struct mlx4_cmd_mailbox
*inbox
)
3732 u32 ts
= (be32_to_cpu(qpc
->flags
) >> 16) & 0xff;
3733 u8 sched
= *(u8
*)(inbox
->buf
+ 64);
3736 port
= (sched
>> 6 & 1) + 1;
3737 if (mlx4_is_eth(dev
, port
) && (ts
!= MLX4_QP_ST_MLX
)) {
3738 smac_ix
= qpc
->pri_path
.grh_mylmc
& 0x7f;
3739 if (mac_find_smac_ix_in_slave(dev
, slave
, port
, smac_ix
, &mac
))
3745 int mlx4_INIT2RTR_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3746 struct mlx4_vhcr
*vhcr
,
3747 struct mlx4_cmd_mailbox
*inbox
,
3748 struct mlx4_cmd_mailbox
*outbox
,
3749 struct mlx4_cmd_info
*cmd
)
3752 struct mlx4_qp_context
*qpc
= inbox
->buf
+ 8;
3753 int qpn
= vhcr
->in_modifier
& 0x7fffff;
3755 u8 orig_sched_queue
;
3756 __be32 orig_param3
= qpc
->param3
;
3757 u8 orig_vlan_control
= qpc
->pri_path
.vlan_control
;
3758 u8 orig_fvl_rx
= qpc
->pri_path
.fvl_rx
;
3759 u8 orig_pri_path_fl
= qpc
->pri_path
.fl
;
3760 u8 orig_vlan_index
= qpc
->pri_path
.vlan_index
;
3761 u8 orig_feup
= qpc
->pri_path
.feup
;
3763 err
= adjust_qp_sched_queue(dev
, slave
, qpc
, inbox
);
3766 err
= verify_qp_parameters(dev
, vhcr
, inbox
, QP_TRANS_INIT2RTR
, slave
);
3770 if (roce_verify_mac(dev
, slave
, qpc
, inbox
))
3773 update_pkey_index(dev
, slave
, inbox
);
3774 update_gid(dev
, inbox
, (u8
)slave
);
3775 adjust_proxy_tun_qkey(dev
, vhcr
, qpc
);
3776 orig_sched_queue
= qpc
->pri_path
.sched_queue
;
3778 err
= get_res(dev
, slave
, qpn
, RES_QP
, &qp
);
3781 if (qp
->com
.from_state
!= RES_QP_HW
) {
3786 err
= update_vport_qp_param(dev
, inbox
, slave
, qpn
);
3790 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3792 /* if no error, save sched queue value passed in by VF. This is
3793 * essentially the QOS value provided by the VF. This will be useful
3794 * if we allow dynamic changes from VST back to VGT
3797 qp
->sched_queue
= orig_sched_queue
;
3798 qp
->param3
= orig_param3
;
3799 qp
->vlan_control
= orig_vlan_control
;
3800 qp
->fvl_rx
= orig_fvl_rx
;
3801 qp
->pri_path_fl
= orig_pri_path_fl
;
3802 qp
->vlan_index
= orig_vlan_index
;
3803 qp
->feup
= orig_feup
;
3805 put_res(dev
, slave
, qpn
, RES_QP
);
3809 int mlx4_RTR2RTS_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3810 struct mlx4_vhcr
*vhcr
,
3811 struct mlx4_cmd_mailbox
*inbox
,
3812 struct mlx4_cmd_mailbox
*outbox
,
3813 struct mlx4_cmd_info
*cmd
)
3816 struct mlx4_qp_context
*context
= inbox
->buf
+ 8;
3818 err
= adjust_qp_sched_queue(dev
, slave
, context
, inbox
);
3821 err
= verify_qp_parameters(dev
, vhcr
, inbox
, QP_TRANS_RTR2RTS
, slave
);
3825 update_pkey_index(dev
, slave
, inbox
);
3826 update_gid(dev
, inbox
, (u8
)slave
);
3827 adjust_proxy_tun_qkey(dev
, vhcr
, context
);
3828 return mlx4_GEN_QP_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3831 int mlx4_RTS2RTS_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3832 struct mlx4_vhcr
*vhcr
,
3833 struct mlx4_cmd_mailbox
*inbox
,
3834 struct mlx4_cmd_mailbox
*outbox
,
3835 struct mlx4_cmd_info
*cmd
)
3838 struct mlx4_qp_context
*context
= inbox
->buf
+ 8;
3840 err
= adjust_qp_sched_queue(dev
, slave
, context
, inbox
);
3843 err
= verify_qp_parameters(dev
, vhcr
, inbox
, QP_TRANS_RTS2RTS
, slave
);
3847 update_pkey_index(dev
, slave
, inbox
);
3848 update_gid(dev
, inbox
, (u8
)slave
);
3849 adjust_proxy_tun_qkey(dev
, vhcr
, context
);
3850 return mlx4_GEN_QP_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3854 int mlx4_SQERR2RTS_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3855 struct mlx4_vhcr
*vhcr
,
3856 struct mlx4_cmd_mailbox
*inbox
,
3857 struct mlx4_cmd_mailbox
*outbox
,
3858 struct mlx4_cmd_info
*cmd
)
3860 struct mlx4_qp_context
*context
= inbox
->buf
+ 8;
3861 int err
= adjust_qp_sched_queue(dev
, slave
, context
, inbox
);
3864 adjust_proxy_tun_qkey(dev
, vhcr
, context
);
3865 return mlx4_GEN_QP_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3868 int mlx4_SQD2SQD_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3869 struct mlx4_vhcr
*vhcr
,
3870 struct mlx4_cmd_mailbox
*inbox
,
3871 struct mlx4_cmd_mailbox
*outbox
,
3872 struct mlx4_cmd_info
*cmd
)
3875 struct mlx4_qp_context
*context
= inbox
->buf
+ 8;
3877 err
= adjust_qp_sched_queue(dev
, slave
, context
, inbox
);
3880 err
= verify_qp_parameters(dev
, vhcr
, inbox
, QP_TRANS_SQD2SQD
, slave
);
3884 adjust_proxy_tun_qkey(dev
, vhcr
, context
);
3885 update_gid(dev
, inbox
, (u8
)slave
);
3886 update_pkey_index(dev
, slave
, inbox
);
3887 return mlx4_GEN_QP_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3890 int mlx4_SQD2RTS_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3891 struct mlx4_vhcr
*vhcr
,
3892 struct mlx4_cmd_mailbox
*inbox
,
3893 struct mlx4_cmd_mailbox
*outbox
,
3894 struct mlx4_cmd_info
*cmd
)
3897 struct mlx4_qp_context
*context
= inbox
->buf
+ 8;
3899 err
= adjust_qp_sched_queue(dev
, slave
, context
, inbox
);
3902 err
= verify_qp_parameters(dev
, vhcr
, inbox
, QP_TRANS_SQD2RTS
, slave
);
3906 adjust_proxy_tun_qkey(dev
, vhcr
, context
);
3907 update_gid(dev
, inbox
, (u8
)slave
);
3908 update_pkey_index(dev
, slave
, inbox
);
3909 return mlx4_GEN_QP_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3912 int mlx4_2RST_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
3913 struct mlx4_vhcr
*vhcr
,
3914 struct mlx4_cmd_mailbox
*inbox
,
3915 struct mlx4_cmd_mailbox
*outbox
,
3916 struct mlx4_cmd_info
*cmd
)
3919 int qpn
= vhcr
->in_modifier
& 0x7fffff;
3922 err
= qp_res_start_move_to(dev
, slave
, qpn
, RES_QP_MAPPED
, &qp
, 0);
3925 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
3929 atomic_dec(&qp
->mtt
->ref_count
);
3930 atomic_dec(&qp
->rcq
->ref_count
);
3931 atomic_dec(&qp
->scq
->ref_count
);
3933 atomic_dec(&qp
->srq
->ref_count
);
3934 res_end_move(dev
, slave
, RES_QP
, qpn
);
3938 res_abort_move(dev
, slave
, RES_QP
, qpn
);
3943 static struct res_gid
*find_gid(struct mlx4_dev
*dev
, int slave
,
3944 struct res_qp
*rqp
, u8
*gid
)
3946 struct res_gid
*res
;
3948 list_for_each_entry(res
, &rqp
->mcg_list
, list
) {
3949 if (!memcmp(res
->gid
, gid
, 16))
3955 static int add_mcg_res(struct mlx4_dev
*dev
, int slave
, struct res_qp
*rqp
,
3956 u8
*gid
, enum mlx4_protocol prot
,
3957 enum mlx4_steer_type steer
, u64 reg_id
)
3959 struct res_gid
*res
;
3962 res
= kzalloc(sizeof *res
, GFP_KERNEL
);
3966 spin_lock_irq(&rqp
->mcg_spl
);
3967 if (find_gid(dev
, slave
, rqp
, gid
)) {
3971 memcpy(res
->gid
, gid
, 16);
3974 res
->reg_id
= reg_id
;
3975 list_add_tail(&res
->list
, &rqp
->mcg_list
);
3978 spin_unlock_irq(&rqp
->mcg_spl
);
3983 static int rem_mcg_res(struct mlx4_dev
*dev
, int slave
, struct res_qp
*rqp
,
3984 u8
*gid
, enum mlx4_protocol prot
,
3985 enum mlx4_steer_type steer
, u64
*reg_id
)
3987 struct res_gid
*res
;
3990 spin_lock_irq(&rqp
->mcg_spl
);
3991 res
= find_gid(dev
, slave
, rqp
, gid
);
3992 if (!res
|| res
->prot
!= prot
|| res
->steer
!= steer
)
3995 *reg_id
= res
->reg_id
;
3996 list_del(&res
->list
);
4000 spin_unlock_irq(&rqp
->mcg_spl
);
4005 static int qp_attach(struct mlx4_dev
*dev
, int slave
, struct mlx4_qp
*qp
,
4006 u8 gid
[16], int block_loopback
, enum mlx4_protocol prot
,
4007 enum mlx4_steer_type type
, u64
*reg_id
)
4009 switch (dev
->caps
.steering_mode
) {
4010 case MLX4_STEERING_MODE_DEVICE_MANAGED
: {
4011 int port
= mlx4_slave_convert_port(dev
, slave
, gid
[5]);
4014 return mlx4_trans_to_dmfs_attach(dev
, qp
, gid
, port
,
4015 block_loopback
, prot
,
4018 case MLX4_STEERING_MODE_B0
:
4019 if (prot
== MLX4_PROT_ETH
) {
4020 int port
= mlx4_slave_convert_port(dev
, slave
, gid
[5]);
4025 return mlx4_qp_attach_common(dev
, qp
, gid
,
4026 block_loopback
, prot
, type
);
4032 static int qp_detach(struct mlx4_dev
*dev
, struct mlx4_qp
*qp
,
4033 u8 gid
[16], enum mlx4_protocol prot
,
4034 enum mlx4_steer_type type
, u64 reg_id
)
4036 switch (dev
->caps
.steering_mode
) {
4037 case MLX4_STEERING_MODE_DEVICE_MANAGED
:
4038 return mlx4_flow_detach(dev
, reg_id
);
4039 case MLX4_STEERING_MODE_B0
:
4040 return mlx4_qp_detach_common(dev
, qp
, gid
, prot
, type
);
4046 static int mlx4_adjust_port(struct mlx4_dev
*dev
, int slave
,
4047 u8
*gid
, enum mlx4_protocol prot
)
4051 if (prot
!= MLX4_PROT_ETH
)
4054 if (dev
->caps
.steering_mode
== MLX4_STEERING_MODE_B0
||
4055 dev
->caps
.steering_mode
== MLX4_STEERING_MODE_DEVICE_MANAGED
) {
4056 real_port
= mlx4_slave_convert_port(dev
, slave
, gid
[5]);
4065 int mlx4_QP_ATTACH_wrapper(struct mlx4_dev
*dev
, int slave
,
4066 struct mlx4_vhcr
*vhcr
,
4067 struct mlx4_cmd_mailbox
*inbox
,
4068 struct mlx4_cmd_mailbox
*outbox
,
4069 struct mlx4_cmd_info
*cmd
)
4071 struct mlx4_qp qp
; /* dummy for calling attach/detach */
4072 u8
*gid
= inbox
->buf
;
4073 enum mlx4_protocol prot
= (vhcr
->in_modifier
>> 28) & 0x7;
4078 int attach
= vhcr
->op_modifier
;
4079 int block_loopback
= vhcr
->in_modifier
>> 31;
4080 u8 steer_type_mask
= 2;
4081 enum mlx4_steer_type type
= (gid
[7] & steer_type_mask
) >> 1;
4083 qpn
= vhcr
->in_modifier
& 0xffffff;
4084 err
= get_res(dev
, slave
, qpn
, RES_QP
, &rqp
);
4090 err
= qp_attach(dev
, slave
, &qp
, gid
, block_loopback
, prot
,
4093 pr_err("Fail to attach rule to qp 0x%x\n", qpn
);
4096 err
= add_mcg_res(dev
, slave
, rqp
, gid
, prot
, type
, reg_id
);
4100 err
= mlx4_adjust_port(dev
, slave
, gid
, prot
);
4104 err
= rem_mcg_res(dev
, slave
, rqp
, gid
, prot
, type
, ®_id
);
4108 err
= qp_detach(dev
, &qp
, gid
, prot
, type
, reg_id
);
4110 pr_err("Fail to detach rule from qp 0x%x reg_id = 0x%llx\n",
4113 put_res(dev
, slave
, qpn
, RES_QP
);
4117 qp_detach(dev
, &qp
, gid
, prot
, type
, reg_id
);
4119 put_res(dev
, slave
, qpn
, RES_QP
);
4124 * MAC validation for Flow Steering rules.
4125 * VF can attach rules only with a mac address which is assigned to it.
4127 static int validate_eth_header_mac(int slave
, struct _rule_hw
*eth_header
,
4128 struct list_head
*rlist
)
4130 struct mac_res
*res
, *tmp
;
4133 /* make sure it isn't multicast or broadcast mac*/
4134 if (!is_multicast_ether_addr(eth_header
->eth
.dst_mac
) &&
4135 !is_broadcast_ether_addr(eth_header
->eth
.dst_mac
)) {
4136 list_for_each_entry_safe(res
, tmp
, rlist
, list
) {
4137 be_mac
= cpu_to_be64(res
->mac
<< 16);
4138 if (ether_addr_equal((u8
*)&be_mac
, eth_header
->eth
.dst_mac
))
4141 pr_err("MAC %pM doesn't belong to VF %d, Steering rule rejected\n",
4142 eth_header
->eth
.dst_mac
, slave
);
4148 static void handle_eth_header_mcast_prio(struct mlx4_net_trans_rule_hw_ctrl
*ctrl
,
4149 struct _rule_hw
*eth_header
)
4151 if (is_multicast_ether_addr(eth_header
->eth
.dst_mac
) ||
4152 is_broadcast_ether_addr(eth_header
->eth
.dst_mac
)) {
4153 struct mlx4_net_trans_rule_hw_eth
*eth
=
4154 (struct mlx4_net_trans_rule_hw_eth
*)eth_header
;
4155 struct _rule_hw
*next_rule
= (struct _rule_hw
*)(eth
+ 1);
4156 bool last_rule
= next_rule
->size
== 0 && next_rule
->id
== 0 &&
4157 next_rule
->rsvd
== 0;
4160 ctrl
->prio
= cpu_to_be16(MLX4_DOMAIN_NIC
);
4165 * In case of missing eth header, append eth header with a MAC address
4166 * assigned to the VF.
4168 static int add_eth_header(struct mlx4_dev
*dev
, int slave
,
4169 struct mlx4_cmd_mailbox
*inbox
,
4170 struct list_head
*rlist
, int header_id
)
4172 struct mac_res
*res
, *tmp
;
4174 struct mlx4_net_trans_rule_hw_ctrl
*ctrl
;
4175 struct mlx4_net_trans_rule_hw_eth
*eth_header
;
4176 struct mlx4_net_trans_rule_hw_ipv4
*ip_header
;
4177 struct mlx4_net_trans_rule_hw_tcp_udp
*l4_header
;
4179 __be64 mac_msk
= cpu_to_be64(MLX4_MAC_MASK
<< 16);
4181 ctrl
= (struct mlx4_net_trans_rule_hw_ctrl
*)inbox
->buf
;
4183 eth_header
= (struct mlx4_net_trans_rule_hw_eth
*)(ctrl
+ 1);
4185 /* Clear a space in the inbox for eth header */
4186 switch (header_id
) {
4187 case MLX4_NET_TRANS_RULE_ID_IPV4
:
4189 (struct mlx4_net_trans_rule_hw_ipv4
*)(eth_header
+ 1);
4190 memmove(ip_header
, eth_header
,
4191 sizeof(*ip_header
) + sizeof(*l4_header
));
4193 case MLX4_NET_TRANS_RULE_ID_TCP
:
4194 case MLX4_NET_TRANS_RULE_ID_UDP
:
4195 l4_header
= (struct mlx4_net_trans_rule_hw_tcp_udp
*)
4197 memmove(l4_header
, eth_header
, sizeof(*l4_header
));
4202 list_for_each_entry_safe(res
, tmp
, rlist
, list
) {
4203 if (port
== res
->port
) {
4204 be_mac
= cpu_to_be64(res
->mac
<< 16);
4209 pr_err("Failed adding eth header to FS rule, Can't find matching MAC for port %d\n",
4214 memset(eth_header
, 0, sizeof(*eth_header
));
4215 eth_header
->size
= sizeof(*eth_header
) >> 2;
4216 eth_header
->id
= cpu_to_be16(__sw_id_hw
[MLX4_NET_TRANS_RULE_ID_ETH
]);
4217 memcpy(eth_header
->dst_mac
, &be_mac
, ETH_ALEN
);
4218 memcpy(eth_header
->dst_mac_msk
, &mac_msk
, ETH_ALEN
);
4224 #define MLX4_UPD_QP_PATH_MASK_SUPPORTED ( \
4225 1ULL << MLX4_UPD_QP_PATH_MASK_MAC_INDEX |\
4226 1ULL << MLX4_UPD_QP_PATH_MASK_ETH_SRC_CHECK_MC_LB)
4227 int mlx4_UPDATE_QP_wrapper(struct mlx4_dev
*dev
, int slave
,
4228 struct mlx4_vhcr
*vhcr
,
4229 struct mlx4_cmd_mailbox
*inbox
,
4230 struct mlx4_cmd_mailbox
*outbox
,
4231 struct mlx4_cmd_info
*cmd_info
)
4234 u32 qpn
= vhcr
->in_modifier
& 0xffffff;
4238 u64 pri_addr_path_mask
;
4239 struct mlx4_update_qp_context
*cmd
;
4242 cmd
= (struct mlx4_update_qp_context
*)inbox
->buf
;
4244 pri_addr_path_mask
= be64_to_cpu(cmd
->primary_addr_path_mask
);
4245 if (cmd
->qp_mask
|| cmd
->secondary_addr_path_mask
||
4246 (pri_addr_path_mask
& ~MLX4_UPD_QP_PATH_MASK_SUPPORTED
))
4249 if ((pri_addr_path_mask
&
4250 (1ULL << MLX4_UPD_QP_PATH_MASK_ETH_SRC_CHECK_MC_LB
)) &&
4251 !(dev
->caps
.flags2
&
4252 MLX4_DEV_CAP_FLAG2_UPDATE_QP_SRC_CHECK_LB
)) {
4254 "Src check LB for slave %d isn't supported\n",
4259 /* Just change the smac for the QP */
4260 err
= get_res(dev
, slave
, qpn
, RES_QP
, &rqp
);
4262 mlx4_err(dev
, "Updating qpn 0x%x for slave %d rejected\n", qpn
, slave
);
4266 port
= (rqp
->sched_queue
>> 6 & 1) + 1;
4268 if (pri_addr_path_mask
& (1ULL << MLX4_UPD_QP_PATH_MASK_MAC_INDEX
)) {
4269 smac_index
= cmd
->qp_context
.pri_path
.grh_mylmc
;
4270 err
= mac_find_smac_ix_in_slave(dev
, slave
, port
,
4274 mlx4_err(dev
, "Failed to update qpn 0x%x, MAC is invalid. smac_ix: %d\n",
4280 err
= mlx4_cmd(dev
, inbox
->dma
,
4281 vhcr
->in_modifier
, 0,
4282 MLX4_CMD_UPDATE_QP
, MLX4_CMD_TIME_CLASS_A
,
4285 mlx4_err(dev
, "Failed to update qpn on qpn 0x%x, command failed\n", qpn
);
4290 put_res(dev
, slave
, qpn
, RES_QP
);
4294 static u32
qp_attach_mbox_size(void *mbox
)
4296 u32 size
= sizeof(struct mlx4_net_trans_rule_hw_ctrl
);
4297 struct _rule_hw
*rule_header
;
4299 rule_header
= (struct _rule_hw
*)(mbox
+ size
);
4301 while (rule_header
->size
) {
4302 size
+= rule_header
->size
* sizeof(u32
);
4308 static int mlx4_do_mirror_rule(struct mlx4_dev
*dev
, struct res_fs_rule
*fs_rule
);
4310 int mlx4_QP_FLOW_STEERING_ATTACH_wrapper(struct mlx4_dev
*dev
, int slave
,
4311 struct mlx4_vhcr
*vhcr
,
4312 struct mlx4_cmd_mailbox
*inbox
,
4313 struct mlx4_cmd_mailbox
*outbox
,
4314 struct mlx4_cmd_info
*cmd
)
4317 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4318 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
4319 struct list_head
*rlist
= &tracker
->slave_list
[slave
].res_list
[RES_MAC
];
4323 struct mlx4_net_trans_rule_hw_ctrl
*ctrl
;
4324 struct _rule_hw
*rule_header
;
4326 struct res_fs_rule
*rrule
;
4329 if (dev
->caps
.steering_mode
!=
4330 MLX4_STEERING_MODE_DEVICE_MANAGED
)
4333 ctrl
= (struct mlx4_net_trans_rule_hw_ctrl
*)inbox
->buf
;
4334 err
= mlx4_slave_convert_port(dev
, slave
, ctrl
->port
);
4338 qpn
= be32_to_cpu(ctrl
->qpn
) & 0xffffff;
4339 err
= get_res(dev
, slave
, qpn
, RES_QP
, &rqp
);
4341 pr_err("Steering rule with qpn 0x%x rejected\n", qpn
);
4344 rule_header
= (struct _rule_hw
*)(ctrl
+ 1);
4345 header_id
= map_hw_to_sw_id(be16_to_cpu(rule_header
->id
));
4347 if (header_id
== MLX4_NET_TRANS_RULE_ID_ETH
)
4348 handle_eth_header_mcast_prio(ctrl
, rule_header
);
4350 if (slave
== dev
->caps
.function
)
4353 switch (header_id
) {
4354 case MLX4_NET_TRANS_RULE_ID_ETH
:
4355 if (validate_eth_header_mac(slave
, rule_header
, rlist
)) {
4360 case MLX4_NET_TRANS_RULE_ID_IB
:
4362 case MLX4_NET_TRANS_RULE_ID_IPV4
:
4363 case MLX4_NET_TRANS_RULE_ID_TCP
:
4364 case MLX4_NET_TRANS_RULE_ID_UDP
:
4365 pr_warn("Can't attach FS rule without L2 headers, adding L2 header\n");
4366 if (add_eth_header(dev
, slave
, inbox
, rlist
, header_id
)) {
4370 vhcr
->in_modifier
+=
4371 sizeof(struct mlx4_net_trans_rule_hw_eth
) >> 2;
4374 pr_err("Corrupted mailbox\n");
4380 err
= mlx4_cmd_imm(dev
, inbox
->dma
, &vhcr
->out_param
,
4381 vhcr
->in_modifier
, 0,
4382 MLX4_QP_FLOW_STEERING_ATTACH
, MLX4_CMD_TIME_CLASS_A
,
4388 err
= add_res_range(dev
, slave
, vhcr
->out_param
, 1, RES_FS_RULE
, qpn
);
4390 mlx4_err(dev
, "Fail to add flow steering resources\n");
4394 err
= get_res(dev
, slave
, vhcr
->out_param
, RES_FS_RULE
, &rrule
);
4398 mbox_size
= qp_attach_mbox_size(inbox
->buf
);
4399 rrule
->mirr_mbox
= kmalloc(mbox_size
, GFP_KERNEL
);
4400 if (!rrule
->mirr_mbox
) {
4404 rrule
->mirr_mbox_size
= mbox_size
;
4405 rrule
->mirr_rule_id
= 0;
4406 memcpy(rrule
->mirr_mbox
, inbox
->buf
, mbox_size
);
4408 /* set different port */
4409 ctrl
= (struct mlx4_net_trans_rule_hw_ctrl
*)rrule
->mirr_mbox
;
4410 if (ctrl
->port
== 1)
4415 if (mlx4_is_bonded(dev
))
4416 mlx4_do_mirror_rule(dev
, rrule
);
4418 atomic_inc(&rqp
->ref_count
);
4421 put_res(dev
, slave
, vhcr
->out_param
, RES_FS_RULE
);
4423 /* detach rule on error */
4425 mlx4_cmd(dev
, vhcr
->out_param
, 0, 0,
4426 MLX4_QP_FLOW_STEERING_DETACH
, MLX4_CMD_TIME_CLASS_A
,
4429 put_res(dev
, slave
, qpn
, RES_QP
);
4433 static int mlx4_undo_mirror_rule(struct mlx4_dev
*dev
, struct res_fs_rule
*fs_rule
)
4437 err
= rem_res_range(dev
, fs_rule
->com
.owner
, fs_rule
->com
.res_id
, 1, RES_FS_RULE
, 0);
4439 mlx4_err(dev
, "Fail to remove flow steering resources\n");
4443 mlx4_cmd(dev
, fs_rule
->com
.res_id
, 0, 0, MLX4_QP_FLOW_STEERING_DETACH
,
4444 MLX4_CMD_TIME_CLASS_A
, MLX4_CMD_NATIVE
);
4448 int mlx4_QP_FLOW_STEERING_DETACH_wrapper(struct mlx4_dev
*dev
, int slave
,
4449 struct mlx4_vhcr
*vhcr
,
4450 struct mlx4_cmd_mailbox
*inbox
,
4451 struct mlx4_cmd_mailbox
*outbox
,
4452 struct mlx4_cmd_info
*cmd
)
4456 struct res_fs_rule
*rrule
;
4459 if (dev
->caps
.steering_mode
!=
4460 MLX4_STEERING_MODE_DEVICE_MANAGED
)
4463 err
= get_res(dev
, slave
, vhcr
->in_param
, RES_FS_RULE
, &rrule
);
4467 if (!rrule
->mirr_mbox
) {
4468 mlx4_err(dev
, "Mirror rules cannot be removed explicitly\n");
4469 put_res(dev
, slave
, vhcr
->in_param
, RES_FS_RULE
);
4472 mirr_reg_id
= rrule
->mirr_rule_id
;
4473 kfree(rrule
->mirr_mbox
);
4475 /* Release the rule form busy state before removal */
4476 put_res(dev
, slave
, vhcr
->in_param
, RES_FS_RULE
);
4477 err
= get_res(dev
, slave
, rrule
->qpn
, RES_QP
, &rqp
);
4481 if (mirr_reg_id
&& mlx4_is_bonded(dev
)) {
4482 err
= get_res(dev
, slave
, mirr_reg_id
, RES_FS_RULE
, &rrule
);
4484 mlx4_err(dev
, "Fail to get resource of mirror rule\n");
4486 put_res(dev
, slave
, mirr_reg_id
, RES_FS_RULE
);
4487 mlx4_undo_mirror_rule(dev
, rrule
);
4490 err
= rem_res_range(dev
, slave
, vhcr
->in_param
, 1, RES_FS_RULE
, 0);
4492 mlx4_err(dev
, "Fail to remove flow steering resources\n");
4496 err
= mlx4_cmd(dev
, vhcr
->in_param
, 0, 0,
4497 MLX4_QP_FLOW_STEERING_DETACH
, MLX4_CMD_TIME_CLASS_A
,
4500 atomic_dec(&rqp
->ref_count
);
4502 put_res(dev
, slave
, rrule
->qpn
, RES_QP
);
4507 BUSY_MAX_RETRIES
= 10
4510 int mlx4_QUERY_IF_STAT_wrapper(struct mlx4_dev
*dev
, int slave
,
4511 struct mlx4_vhcr
*vhcr
,
4512 struct mlx4_cmd_mailbox
*inbox
,
4513 struct mlx4_cmd_mailbox
*outbox
,
4514 struct mlx4_cmd_info
*cmd
)
4517 int index
= vhcr
->in_modifier
& 0xffff;
4519 err
= get_res(dev
, slave
, index
, RES_COUNTER
, NULL
);
4523 err
= mlx4_DMA_wrapper(dev
, slave
, vhcr
, inbox
, outbox
, cmd
);
4524 put_res(dev
, slave
, index
, RES_COUNTER
);
4528 static void detach_qp(struct mlx4_dev
*dev
, int slave
, struct res_qp
*rqp
)
4530 struct res_gid
*rgid
;
4531 struct res_gid
*tmp
;
4532 struct mlx4_qp qp
; /* dummy for calling attach/detach */
4534 list_for_each_entry_safe(rgid
, tmp
, &rqp
->mcg_list
, list
) {
4535 switch (dev
->caps
.steering_mode
) {
4536 case MLX4_STEERING_MODE_DEVICE_MANAGED
:
4537 mlx4_flow_detach(dev
, rgid
->reg_id
);
4539 case MLX4_STEERING_MODE_B0
:
4540 qp
.qpn
= rqp
->local_qpn
;
4541 (void) mlx4_qp_detach_common(dev
, &qp
, rgid
->gid
,
4542 rgid
->prot
, rgid
->steer
);
4545 list_del(&rgid
->list
);
4550 static int _move_all_busy(struct mlx4_dev
*dev
, int slave
,
4551 enum mlx4_resource type
, int print
)
4553 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4554 struct mlx4_resource_tracker
*tracker
=
4555 &priv
->mfunc
.master
.res_tracker
;
4556 struct list_head
*rlist
= &tracker
->slave_list
[slave
].res_list
[type
];
4557 struct res_common
*r
;
4558 struct res_common
*tmp
;
4562 spin_lock_irq(mlx4_tlock(dev
));
4563 list_for_each_entry_safe(r
, tmp
, rlist
, list
) {
4564 if (r
->owner
== slave
) {
4566 if (r
->state
== RES_ANY_BUSY
) {
4569 "%s id 0x%llx is busy\n",
4574 r
->from_state
= r
->state
;
4575 r
->state
= RES_ANY_BUSY
;
4581 spin_unlock_irq(mlx4_tlock(dev
));
4586 static int move_all_busy(struct mlx4_dev
*dev
, int slave
,
4587 enum mlx4_resource type
)
4589 unsigned long begin
;
4594 busy
= _move_all_busy(dev
, slave
, type
, 0);
4595 if (time_after(jiffies
, begin
+ 5 * HZ
))
4602 busy
= _move_all_busy(dev
, slave
, type
, 1);
4606 static void rem_slave_qps(struct mlx4_dev
*dev
, int slave
)
4608 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4609 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
4610 struct list_head
*qp_list
=
4611 &tracker
->slave_list
[slave
].res_list
[RES_QP
];
4619 err
= move_all_busy(dev
, slave
, RES_QP
);
4621 mlx4_warn(dev
, "rem_slave_qps: Could not move all qps to busy for slave %d\n",
4624 spin_lock_irq(mlx4_tlock(dev
));
4625 list_for_each_entry_safe(qp
, tmp
, qp_list
, com
.list
) {
4626 spin_unlock_irq(mlx4_tlock(dev
));
4627 if (qp
->com
.owner
== slave
) {
4628 qpn
= qp
->com
.res_id
;
4629 detach_qp(dev
, slave
, qp
);
4630 state
= qp
->com
.from_state
;
4631 while (state
!= 0) {
4633 case RES_QP_RESERVED
:
4634 spin_lock_irq(mlx4_tlock(dev
));
4635 rb_erase(&qp
->com
.node
,
4636 &tracker
->res_tree
[RES_QP
]);
4637 list_del(&qp
->com
.list
);
4638 spin_unlock_irq(mlx4_tlock(dev
));
4639 if (!valid_reserved(dev
, slave
, qpn
)) {
4640 __mlx4_qp_release_range(dev
, qpn
, 1);
4641 mlx4_release_resource(dev
, slave
,
4648 if (!valid_reserved(dev
, slave
, qpn
))
4649 __mlx4_qp_free_icm(dev
, qpn
);
4650 state
= RES_QP_RESERVED
;
4654 err
= mlx4_cmd(dev
, in_param
,
4657 MLX4_CMD_TIME_CLASS_A
,
4660 mlx4_dbg(dev
, "rem_slave_qps: failed to move slave %d qpn %d to reset\n",
4661 slave
, qp
->local_qpn
);
4662 atomic_dec(&qp
->rcq
->ref_count
);
4663 atomic_dec(&qp
->scq
->ref_count
);
4664 atomic_dec(&qp
->mtt
->ref_count
);
4666 atomic_dec(&qp
->srq
->ref_count
);
4667 state
= RES_QP_MAPPED
;
4674 spin_lock_irq(mlx4_tlock(dev
));
4676 spin_unlock_irq(mlx4_tlock(dev
));
4679 static void rem_slave_srqs(struct mlx4_dev
*dev
, int slave
)
4681 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4682 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
4683 struct list_head
*srq_list
=
4684 &tracker
->slave_list
[slave
].res_list
[RES_SRQ
];
4685 struct res_srq
*srq
;
4686 struct res_srq
*tmp
;
4693 err
= move_all_busy(dev
, slave
, RES_SRQ
);
4695 mlx4_warn(dev
, "rem_slave_srqs: Could not move all srqs - too busy for slave %d\n",
4698 spin_lock_irq(mlx4_tlock(dev
));
4699 list_for_each_entry_safe(srq
, tmp
, srq_list
, com
.list
) {
4700 spin_unlock_irq(mlx4_tlock(dev
));
4701 if (srq
->com
.owner
== slave
) {
4702 srqn
= srq
->com
.res_id
;
4703 state
= srq
->com
.from_state
;
4704 while (state
!= 0) {
4706 case RES_SRQ_ALLOCATED
:
4707 __mlx4_srq_free_icm(dev
, srqn
);
4708 spin_lock_irq(mlx4_tlock(dev
));
4709 rb_erase(&srq
->com
.node
,
4710 &tracker
->res_tree
[RES_SRQ
]);
4711 list_del(&srq
->com
.list
);
4712 spin_unlock_irq(mlx4_tlock(dev
));
4713 mlx4_release_resource(dev
, slave
,
4721 err
= mlx4_cmd(dev
, in_param
, srqn
, 1,
4723 MLX4_CMD_TIME_CLASS_A
,
4726 mlx4_dbg(dev
, "rem_slave_srqs: failed to move slave %d srq %d to SW ownership\n",
4729 atomic_dec(&srq
->mtt
->ref_count
);
4731 atomic_dec(&srq
->cq
->ref_count
);
4732 state
= RES_SRQ_ALLOCATED
;
4740 spin_lock_irq(mlx4_tlock(dev
));
4742 spin_unlock_irq(mlx4_tlock(dev
));
4745 static void rem_slave_cqs(struct mlx4_dev
*dev
, int slave
)
4747 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4748 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
4749 struct list_head
*cq_list
=
4750 &tracker
->slave_list
[slave
].res_list
[RES_CQ
];
4759 err
= move_all_busy(dev
, slave
, RES_CQ
);
4761 mlx4_warn(dev
, "rem_slave_cqs: Could not move all cqs - too busy for slave %d\n",
4764 spin_lock_irq(mlx4_tlock(dev
));
4765 list_for_each_entry_safe(cq
, tmp
, cq_list
, com
.list
) {
4766 spin_unlock_irq(mlx4_tlock(dev
));
4767 if (cq
->com
.owner
== slave
&& !atomic_read(&cq
->ref_count
)) {
4768 cqn
= cq
->com
.res_id
;
4769 state
= cq
->com
.from_state
;
4770 while (state
!= 0) {
4772 case RES_CQ_ALLOCATED
:
4773 __mlx4_cq_free_icm(dev
, cqn
);
4774 spin_lock_irq(mlx4_tlock(dev
));
4775 rb_erase(&cq
->com
.node
,
4776 &tracker
->res_tree
[RES_CQ
]);
4777 list_del(&cq
->com
.list
);
4778 spin_unlock_irq(mlx4_tlock(dev
));
4779 mlx4_release_resource(dev
, slave
,
4787 err
= mlx4_cmd(dev
, in_param
, cqn
, 1,
4789 MLX4_CMD_TIME_CLASS_A
,
4792 mlx4_dbg(dev
, "rem_slave_cqs: failed to move slave %d cq %d to SW ownership\n",
4794 atomic_dec(&cq
->mtt
->ref_count
);
4795 state
= RES_CQ_ALLOCATED
;
4803 spin_lock_irq(mlx4_tlock(dev
));
4805 spin_unlock_irq(mlx4_tlock(dev
));
4808 static void rem_slave_mrs(struct mlx4_dev
*dev
, int slave
)
4810 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4811 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
4812 struct list_head
*mpt_list
=
4813 &tracker
->slave_list
[slave
].res_list
[RES_MPT
];
4814 struct res_mpt
*mpt
;
4815 struct res_mpt
*tmp
;
4822 err
= move_all_busy(dev
, slave
, RES_MPT
);
4824 mlx4_warn(dev
, "rem_slave_mrs: Could not move all mpts - too busy for slave %d\n",
4827 spin_lock_irq(mlx4_tlock(dev
));
4828 list_for_each_entry_safe(mpt
, tmp
, mpt_list
, com
.list
) {
4829 spin_unlock_irq(mlx4_tlock(dev
));
4830 if (mpt
->com
.owner
== slave
) {
4831 mptn
= mpt
->com
.res_id
;
4832 state
= mpt
->com
.from_state
;
4833 while (state
!= 0) {
4835 case RES_MPT_RESERVED
:
4836 __mlx4_mpt_release(dev
, mpt
->key
);
4837 spin_lock_irq(mlx4_tlock(dev
));
4838 rb_erase(&mpt
->com
.node
,
4839 &tracker
->res_tree
[RES_MPT
]);
4840 list_del(&mpt
->com
.list
);
4841 spin_unlock_irq(mlx4_tlock(dev
));
4842 mlx4_release_resource(dev
, slave
,
4848 case RES_MPT_MAPPED
:
4849 __mlx4_mpt_free_icm(dev
, mpt
->key
);
4850 state
= RES_MPT_RESERVED
;
4855 err
= mlx4_cmd(dev
, in_param
, mptn
, 0,
4857 MLX4_CMD_TIME_CLASS_A
,
4860 mlx4_dbg(dev
, "rem_slave_mrs: failed to move slave %d mpt %d to SW ownership\n",
4863 atomic_dec(&mpt
->mtt
->ref_count
);
4864 state
= RES_MPT_MAPPED
;
4871 spin_lock_irq(mlx4_tlock(dev
));
4873 spin_unlock_irq(mlx4_tlock(dev
));
4876 static void rem_slave_mtts(struct mlx4_dev
*dev
, int slave
)
4878 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4879 struct mlx4_resource_tracker
*tracker
=
4880 &priv
->mfunc
.master
.res_tracker
;
4881 struct list_head
*mtt_list
=
4882 &tracker
->slave_list
[slave
].res_list
[RES_MTT
];
4883 struct res_mtt
*mtt
;
4884 struct res_mtt
*tmp
;
4890 err
= move_all_busy(dev
, slave
, RES_MTT
);
4892 mlx4_warn(dev
, "rem_slave_mtts: Could not move all mtts - too busy for slave %d\n",
4895 spin_lock_irq(mlx4_tlock(dev
));
4896 list_for_each_entry_safe(mtt
, tmp
, mtt_list
, com
.list
) {
4897 spin_unlock_irq(mlx4_tlock(dev
));
4898 if (mtt
->com
.owner
== slave
) {
4899 base
= mtt
->com
.res_id
;
4900 state
= mtt
->com
.from_state
;
4901 while (state
!= 0) {
4903 case RES_MTT_ALLOCATED
:
4904 __mlx4_free_mtt_range(dev
, base
,
4906 spin_lock_irq(mlx4_tlock(dev
));
4907 rb_erase(&mtt
->com
.node
,
4908 &tracker
->res_tree
[RES_MTT
]);
4909 list_del(&mtt
->com
.list
);
4910 spin_unlock_irq(mlx4_tlock(dev
));
4911 mlx4_release_resource(dev
, slave
, RES_MTT
,
4912 1 << mtt
->order
, 0);
4922 spin_lock_irq(mlx4_tlock(dev
));
4924 spin_unlock_irq(mlx4_tlock(dev
));
4927 static int mlx4_do_mirror_rule(struct mlx4_dev
*dev
, struct res_fs_rule
*fs_rule
)
4929 struct mlx4_cmd_mailbox
*mailbox
;
4931 struct res_fs_rule
*mirr_rule
;
4934 mailbox
= mlx4_alloc_cmd_mailbox(dev
);
4935 if (IS_ERR(mailbox
))
4936 return PTR_ERR(mailbox
);
4938 if (!fs_rule
->mirr_mbox
) {
4939 mlx4_err(dev
, "rule mirroring mailbox is null\n");
4942 memcpy(mailbox
->buf
, fs_rule
->mirr_mbox
, fs_rule
->mirr_mbox_size
);
4943 err
= mlx4_cmd_imm(dev
, mailbox
->dma
, ®_id
, fs_rule
->mirr_mbox_size
>> 2, 0,
4944 MLX4_QP_FLOW_STEERING_ATTACH
, MLX4_CMD_TIME_CLASS_A
,
4946 mlx4_free_cmd_mailbox(dev
, mailbox
);
4951 err
= add_res_range(dev
, fs_rule
->com
.owner
, reg_id
, 1, RES_FS_RULE
, fs_rule
->qpn
);
4955 err
= get_res(dev
, fs_rule
->com
.owner
, reg_id
, RES_FS_RULE
, &mirr_rule
);
4959 fs_rule
->mirr_rule_id
= reg_id
;
4960 mirr_rule
->mirr_rule_id
= 0;
4961 mirr_rule
->mirr_mbox_size
= 0;
4962 mirr_rule
->mirr_mbox
= NULL
;
4963 put_res(dev
, fs_rule
->com
.owner
, reg_id
, RES_FS_RULE
);
4967 rem_res_range(dev
, fs_rule
->com
.owner
, reg_id
, 1, RES_FS_RULE
, 0);
4969 mlx4_cmd(dev
, reg_id
, 0, 0, MLX4_QP_FLOW_STEERING_DETACH
,
4970 MLX4_CMD_TIME_CLASS_A
, MLX4_CMD_NATIVE
);
4975 static int mlx4_mirror_fs_rules(struct mlx4_dev
*dev
, bool bond
)
4977 struct mlx4_priv
*priv
= mlx4_priv(dev
);
4978 struct mlx4_resource_tracker
*tracker
=
4979 &priv
->mfunc
.master
.res_tracker
;
4980 struct rb_root
*root
= &tracker
->res_tree
[RES_FS_RULE
];
4982 struct res_fs_rule
*fs_rule
;
4984 LIST_HEAD(mirr_list
);
4986 for (p
= rb_first(root
); p
; p
= rb_next(p
)) {
4987 fs_rule
= rb_entry(p
, struct res_fs_rule
, com
.node
);
4988 if ((bond
&& fs_rule
->mirr_mbox_size
) ||
4989 (!bond
&& !fs_rule
->mirr_mbox_size
))
4990 list_add_tail(&fs_rule
->mirr_list
, &mirr_list
);
4993 list_for_each_entry(fs_rule
, &mirr_list
, mirr_list
) {
4995 err
+= mlx4_do_mirror_rule(dev
, fs_rule
);
4997 err
+= mlx4_undo_mirror_rule(dev
, fs_rule
);
5002 int mlx4_bond_fs_rules(struct mlx4_dev
*dev
)
5004 return mlx4_mirror_fs_rules(dev
, true);
5007 int mlx4_unbond_fs_rules(struct mlx4_dev
*dev
)
5009 return mlx4_mirror_fs_rules(dev
, false);
5012 static void rem_slave_fs_rule(struct mlx4_dev
*dev
, int slave
)
5014 struct mlx4_priv
*priv
= mlx4_priv(dev
);
5015 struct mlx4_resource_tracker
*tracker
=
5016 &priv
->mfunc
.master
.res_tracker
;
5017 struct list_head
*fs_rule_list
=
5018 &tracker
->slave_list
[slave
].res_list
[RES_FS_RULE
];
5019 struct res_fs_rule
*fs_rule
;
5020 struct res_fs_rule
*tmp
;
5025 err
= move_all_busy(dev
, slave
, RES_FS_RULE
);
5027 mlx4_warn(dev
, "rem_slave_fs_rule: Could not move all mtts to busy for slave %d\n",
5030 spin_lock_irq(mlx4_tlock(dev
));
5031 list_for_each_entry_safe(fs_rule
, tmp
, fs_rule_list
, com
.list
) {
5032 spin_unlock_irq(mlx4_tlock(dev
));
5033 if (fs_rule
->com
.owner
== slave
) {
5034 base
= fs_rule
->com
.res_id
;
5035 state
= fs_rule
->com
.from_state
;
5036 while (state
!= 0) {
5038 case RES_FS_RULE_ALLOCATED
:
5040 err
= mlx4_cmd(dev
, base
, 0, 0,
5041 MLX4_QP_FLOW_STEERING_DETACH
,
5042 MLX4_CMD_TIME_CLASS_A
,
5045 spin_lock_irq(mlx4_tlock(dev
));
5046 rb_erase(&fs_rule
->com
.node
,
5047 &tracker
->res_tree
[RES_FS_RULE
]);
5048 list_del(&fs_rule
->com
.list
);
5049 spin_unlock_irq(mlx4_tlock(dev
));
5059 spin_lock_irq(mlx4_tlock(dev
));
5061 spin_unlock_irq(mlx4_tlock(dev
));
5064 static void rem_slave_eqs(struct mlx4_dev
*dev
, int slave
)
5066 struct mlx4_priv
*priv
= mlx4_priv(dev
);
5067 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
5068 struct list_head
*eq_list
=
5069 &tracker
->slave_list
[slave
].res_list
[RES_EQ
];
5077 err
= move_all_busy(dev
, slave
, RES_EQ
);
5079 mlx4_warn(dev
, "rem_slave_eqs: Could not move all eqs - too busy for slave %d\n",
5082 spin_lock_irq(mlx4_tlock(dev
));
5083 list_for_each_entry_safe(eq
, tmp
, eq_list
, com
.list
) {
5084 spin_unlock_irq(mlx4_tlock(dev
));
5085 if (eq
->com
.owner
== slave
) {
5086 eqn
= eq
->com
.res_id
;
5087 state
= eq
->com
.from_state
;
5088 while (state
!= 0) {
5090 case RES_EQ_RESERVED
:
5091 spin_lock_irq(mlx4_tlock(dev
));
5092 rb_erase(&eq
->com
.node
,
5093 &tracker
->res_tree
[RES_EQ
]);
5094 list_del(&eq
->com
.list
);
5095 spin_unlock_irq(mlx4_tlock(dev
));
5101 err
= mlx4_cmd(dev
, slave
, eqn
& 0x3ff,
5102 1, MLX4_CMD_HW2SW_EQ
,
5103 MLX4_CMD_TIME_CLASS_A
,
5106 mlx4_dbg(dev
, "rem_slave_eqs: failed to move slave %d eqs %d to SW ownership\n",
5107 slave
, eqn
& 0x3ff);
5108 atomic_dec(&eq
->mtt
->ref_count
);
5109 state
= RES_EQ_RESERVED
;
5117 spin_lock_irq(mlx4_tlock(dev
));
5119 spin_unlock_irq(mlx4_tlock(dev
));
5122 static void rem_slave_counters(struct mlx4_dev
*dev
, int slave
)
5124 struct mlx4_priv
*priv
= mlx4_priv(dev
);
5125 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
5126 struct list_head
*counter_list
=
5127 &tracker
->slave_list
[slave
].res_list
[RES_COUNTER
];
5128 struct res_counter
*counter
;
5129 struct res_counter
*tmp
;
5131 int *counters_arr
= NULL
;
5134 err
= move_all_busy(dev
, slave
, RES_COUNTER
);
5136 mlx4_warn(dev
, "rem_slave_counters: Could not move all counters - too busy for slave %d\n",
5139 counters_arr
= kmalloc_array(dev
->caps
.max_counters
,
5140 sizeof(*counters_arr
), GFP_KERNEL
);
5147 spin_lock_irq(mlx4_tlock(dev
));
5148 list_for_each_entry_safe(counter
, tmp
, counter_list
, com
.list
) {
5149 if (counter
->com
.owner
== slave
) {
5150 counters_arr
[i
++] = counter
->com
.res_id
;
5151 rb_erase(&counter
->com
.node
,
5152 &tracker
->res_tree
[RES_COUNTER
]);
5153 list_del(&counter
->com
.list
);
5157 spin_unlock_irq(mlx4_tlock(dev
));
5160 __mlx4_counter_free(dev
, counters_arr
[j
++]);
5161 mlx4_release_resource(dev
, slave
, RES_COUNTER
, 1, 0);
5165 kfree(counters_arr
);
5168 static void rem_slave_xrcdns(struct mlx4_dev
*dev
, int slave
)
5170 struct mlx4_priv
*priv
= mlx4_priv(dev
);
5171 struct mlx4_resource_tracker
*tracker
= &priv
->mfunc
.master
.res_tracker
;
5172 struct list_head
*xrcdn_list
=
5173 &tracker
->slave_list
[slave
].res_list
[RES_XRCD
];
5174 struct res_xrcdn
*xrcd
;
5175 struct res_xrcdn
*tmp
;
5179 err
= move_all_busy(dev
, slave
, RES_XRCD
);
5181 mlx4_warn(dev
, "rem_slave_xrcdns: Could not move all xrcdns - too busy for slave %d\n",
5184 spin_lock_irq(mlx4_tlock(dev
));
5185 list_for_each_entry_safe(xrcd
, tmp
, xrcdn_list
, com
.list
) {
5186 if (xrcd
->com
.owner
== slave
) {
5187 xrcdn
= xrcd
->com
.res_id
;
5188 rb_erase(&xrcd
->com
.node
, &tracker
->res_tree
[RES_XRCD
]);
5189 list_del(&xrcd
->com
.list
);
5191 __mlx4_xrcd_free(dev
, xrcdn
);
5194 spin_unlock_irq(mlx4_tlock(dev
));
5197 void mlx4_delete_all_resources_for_slave(struct mlx4_dev
*dev
, int slave
)
5199 struct mlx4_priv
*priv
= mlx4_priv(dev
);
5200 mlx4_reset_roce_gids(dev
, slave
);
5201 mutex_lock(&priv
->mfunc
.master
.res_tracker
.slave_list
[slave
].mutex
);
5202 rem_slave_vlans(dev
, slave
);
5203 rem_slave_macs(dev
, slave
);
5204 rem_slave_fs_rule(dev
, slave
);
5205 rem_slave_qps(dev
, slave
);
5206 rem_slave_srqs(dev
, slave
);
5207 rem_slave_cqs(dev
, slave
);
5208 rem_slave_mrs(dev
, slave
);
5209 rem_slave_eqs(dev
, slave
);
5210 rem_slave_mtts(dev
, slave
);
5211 rem_slave_counters(dev
, slave
);
5212 rem_slave_xrcdns(dev
, slave
);
5213 mutex_unlock(&priv
->mfunc
.master
.res_tracker
.slave_list
[slave
].mutex
);
5216 void mlx4_vf_immed_vlan_work_handler(struct work_struct
*_work
)
5218 struct mlx4_vf_immed_vlan_work
*work
=
5219 container_of(_work
, struct mlx4_vf_immed_vlan_work
, work
);
5220 struct mlx4_cmd_mailbox
*mailbox
;
5221 struct mlx4_update_qp_context
*upd_context
;
5222 struct mlx4_dev
*dev
= &work
->priv
->dev
;
5223 struct mlx4_resource_tracker
*tracker
=
5224 &work
->priv
->mfunc
.master
.res_tracker
;
5225 struct list_head
*qp_list
=
5226 &tracker
->slave_list
[work
->slave
].res_list
[RES_QP
];
5229 u64 qp_path_mask_vlan_ctrl
=
5230 ((1ULL << MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_UNTAGGED
) |
5231 (1ULL << MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_1P
) |
5232 (1ULL << MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_TAGGED
) |
5233 (1ULL << MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_UNTAGGED
) |
5234 (1ULL << MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_1P
) |
5235 (1ULL << MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_TAGGED
));
5237 u64 qp_path_mask
= ((1ULL << MLX4_UPD_QP_PATH_MASK_VLAN_INDEX
) |
5238 (1ULL << MLX4_UPD_QP_PATH_MASK_FVL
) |
5239 (1ULL << MLX4_UPD_QP_PATH_MASK_CV
) |
5240 (1ULL << MLX4_UPD_QP_PATH_MASK_ETH_HIDE_CQE_VLAN
) |
5241 (1ULL << MLX4_UPD_QP_PATH_MASK_FEUP
) |
5242 (1ULL << MLX4_UPD_QP_PATH_MASK_FVL_RX
) |
5243 (1ULL << MLX4_UPD_QP_PATH_MASK_SCHED_QUEUE
));
5246 int port
, errors
= 0;
5249 if (mlx4_is_slave(dev
)) {
5250 mlx4_warn(dev
, "Trying to update-qp in slave %d\n",
5255 mailbox
= mlx4_alloc_cmd_mailbox(dev
);
5256 if (IS_ERR(mailbox
))
5258 if (work
->flags
& MLX4_VF_IMMED_VLAN_FLAG_LINK_DISABLE
) /* block all */
5259 vlan_control
= MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED
|
5260 MLX4_VLAN_CTRL_ETH_TX_BLOCK_PRIO_TAGGED
|
5261 MLX4_VLAN_CTRL_ETH_TX_BLOCK_UNTAGGED
|
5262 MLX4_VLAN_CTRL_ETH_RX_BLOCK_PRIO_TAGGED
|
5263 MLX4_VLAN_CTRL_ETH_RX_BLOCK_UNTAGGED
|
5264 MLX4_VLAN_CTRL_ETH_RX_BLOCK_TAGGED
;
5265 else if (!work
->vlan_id
)
5266 vlan_control
= MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED
|
5267 MLX4_VLAN_CTRL_ETH_RX_BLOCK_TAGGED
;
5269 vlan_control
= MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED
|
5270 MLX4_VLAN_CTRL_ETH_RX_BLOCK_PRIO_TAGGED
|
5271 MLX4_VLAN_CTRL_ETH_RX_BLOCK_UNTAGGED
;
5273 upd_context
= mailbox
->buf
;
5274 upd_context
->qp_mask
= cpu_to_be64(1ULL << MLX4_UPD_QP_MASK_VSD
);
5276 spin_lock_irq(mlx4_tlock(dev
));
5277 list_for_each_entry_safe(qp
, tmp
, qp_list
, com
.list
) {
5278 spin_unlock_irq(mlx4_tlock(dev
));
5279 if (qp
->com
.owner
== work
->slave
) {
5280 if (qp
->com
.from_state
!= RES_QP_HW
||
5281 !qp
->sched_queue
|| /* no INIT2RTR trans yet */
5282 mlx4_is_qp_reserved(dev
, qp
->local_qpn
) ||
5283 qp
->qpc_flags
& (1 << MLX4_RSS_QPC_FLAG_OFFSET
)) {
5284 spin_lock_irq(mlx4_tlock(dev
));
5287 port
= (qp
->sched_queue
>> 6 & 1) + 1;
5288 if (port
!= work
->port
) {
5289 spin_lock_irq(mlx4_tlock(dev
));
5292 if (MLX4_QP_ST_RC
== ((qp
->qpc_flags
>> 16) & 0xff))
5293 upd_context
->primary_addr_path_mask
= cpu_to_be64(qp_path_mask
);
5295 upd_context
->primary_addr_path_mask
=
5296 cpu_to_be64(qp_path_mask
| qp_path_mask_vlan_ctrl
);
5297 if (work
->vlan_id
== MLX4_VGT
) {
5298 upd_context
->qp_context
.param3
= qp
->param3
;
5299 upd_context
->qp_context
.pri_path
.vlan_control
= qp
->vlan_control
;
5300 upd_context
->qp_context
.pri_path
.fvl_rx
= qp
->fvl_rx
;
5301 upd_context
->qp_context
.pri_path
.vlan_index
= qp
->vlan_index
;
5302 upd_context
->qp_context
.pri_path
.fl
= qp
->pri_path_fl
;
5303 upd_context
->qp_context
.pri_path
.feup
= qp
->feup
;
5304 upd_context
->qp_context
.pri_path
.sched_queue
=
5307 upd_context
->qp_context
.param3
= qp
->param3
& ~cpu_to_be32(MLX4_STRIP_VLAN
);
5308 upd_context
->qp_context
.pri_path
.vlan_control
= vlan_control
;
5309 upd_context
->qp_context
.pri_path
.vlan_index
= work
->vlan_ix
;
5310 upd_context
->qp_context
.pri_path
.fvl_rx
=
5311 qp
->fvl_rx
| MLX4_FVL_RX_FORCE_ETH_VLAN
;
5312 upd_context
->qp_context
.pri_path
.fl
=
5313 qp
->pri_path_fl
| MLX4_FL_CV
| MLX4_FL_ETH_HIDE_CQE_VLAN
;
5314 upd_context
->qp_context
.pri_path
.feup
=
5315 qp
->feup
| MLX4_FEUP_FORCE_ETH_UP
| MLX4_FVL_FORCE_ETH_VLAN
;
5316 upd_context
->qp_context
.pri_path
.sched_queue
=
5317 qp
->sched_queue
& 0xC7;
5318 upd_context
->qp_context
.pri_path
.sched_queue
|=
5319 ((work
->qos
& 0x7) << 3);
5320 upd_context
->qp_mask
|=
5322 MLX4_UPD_QP_MASK_QOS_VPP
);
5323 upd_context
->qp_context
.qos_vport
=
5327 err
= mlx4_cmd(dev
, mailbox
->dma
,
5328 qp
->local_qpn
& 0xffffff,
5329 0, MLX4_CMD_UPDATE_QP
,
5330 MLX4_CMD_TIME_CLASS_C
, MLX4_CMD_NATIVE
);
5332 mlx4_info(dev
, "UPDATE_QP failed for slave %d, port %d, qpn %d (%d)\n",
5333 work
->slave
, port
, qp
->local_qpn
, err
);
5337 spin_lock_irq(mlx4_tlock(dev
));
5339 spin_unlock_irq(mlx4_tlock(dev
));
5340 mlx4_free_cmd_mailbox(dev
, mailbox
);
5343 mlx4_err(dev
, "%d UPDATE_QP failures for slave %d, port %d\n",
5344 errors
, work
->slave
, work
->port
);
5346 /* unregister previous vlan_id if needed and we had no errors
5347 * while updating the QPs
5349 if (work
->flags
& MLX4_VF_IMMED_VLAN_FLAG_VLAN
&& !errors
&&
5350 NO_INDX
!= work
->orig_vlan_ix
)
5351 __mlx4_unregister_vlan(&work
->priv
->dev
, work
->port
,
5352 work
->orig_vlan_id
);