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