2 * Copyright (c) 2006, 2007 Cisco Systems, Inc. All rights reserved.
3 * Copyright (c) 2007, 2008 Mellanox Technologies. All rights reserved.
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 #include <linux/errno.h>
38 #include <linux/netdevice.h>
39 #include <linux/inetdevice.h>
40 #include <linux/rtnetlink.h>
41 #include <linux/if_vlan.h>
43 #include <rdma/ib_smi.h>
44 #include <rdma/ib_user_verbs.h>
45 #include <rdma/ib_addr.h>
47 #include <linux/mlx4/driver.h>
48 #include <linux/mlx4/cmd.h>
53 #define DRV_NAME MLX4_IB_DRV_NAME
54 #define DRV_VERSION "1.0"
55 #define DRV_RELDATE "April 4, 2008"
57 #define MLX4_IB_FLOW_MAX_PRIO 0xFFF
59 MODULE_AUTHOR("Roland Dreier");
60 MODULE_DESCRIPTION("Mellanox ConnectX HCA InfiniBand driver");
61 MODULE_LICENSE("Dual BSD/GPL");
62 MODULE_VERSION(DRV_VERSION
);
64 int mlx4_ib_sm_guid_assign
= 1;
65 module_param_named(sm_guid_assign
, mlx4_ib_sm_guid_assign
, int, 0444);
66 MODULE_PARM_DESC(sm_guid_assign
, "Enable SM alias_GUID assignment if sm_guid_assign > 0 (Default: 1)");
68 static const char mlx4_ib_version
[] =
69 DRV_NAME
": Mellanox ConnectX InfiniBand driver v"
70 DRV_VERSION
" (" DRV_RELDATE
")\n";
72 struct update_gid_work
{
73 struct work_struct work
;
74 union ib_gid gids
[128];
75 struct mlx4_ib_dev
*dev
;
79 static void do_slave_init(struct mlx4_ib_dev
*ibdev
, int slave
, int do_init
);
81 static struct workqueue_struct
*wq
;
83 static void init_query_mad(struct ib_smp
*mad
)
85 mad
->base_version
= 1;
86 mad
->mgmt_class
= IB_MGMT_CLASS_SUBN_LID_ROUTED
;
87 mad
->class_version
= 1;
88 mad
->method
= IB_MGMT_METHOD_GET
;
91 static union ib_gid zgid
;
93 static int check_flow_steering_support(struct mlx4_dev
*dev
)
95 int eth_num_ports
= 0;
98 int dmfs
= dev
->caps
.steering_mode
== MLX4_STEERING_MODE_DEVICE_MANAGED
;
102 mlx4_foreach_port(i
, dev
, MLX4_PORT_TYPE_ETH
)
104 mlx4_foreach_port(i
, dev
, MLX4_PORT_TYPE_IB
)
106 dmfs
&= (!ib_num_ports
||
107 (dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_DMFS_IPOIB
)) &&
109 (dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_FS_EN
));
110 if (ib_num_ports
&& mlx4_is_mfunc(dev
)) {
111 pr_warn("Device managed flow steering is unavailable for IB port in multifunction env.\n");
118 static int mlx4_ib_query_device(struct ib_device
*ibdev
,
119 struct ib_device_attr
*props
)
121 struct mlx4_ib_dev
*dev
= to_mdev(ibdev
);
122 struct ib_smp
*in_mad
= NULL
;
123 struct ib_smp
*out_mad
= NULL
;
126 in_mad
= kzalloc(sizeof *in_mad
, GFP_KERNEL
);
127 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
128 if (!in_mad
|| !out_mad
)
131 init_query_mad(in_mad
);
132 in_mad
->attr_id
= IB_SMP_ATTR_NODE_INFO
;
134 err
= mlx4_MAD_IFC(to_mdev(ibdev
), MLX4_MAD_IFC_IGNORE_KEYS
,
135 1, NULL
, NULL
, in_mad
, out_mad
);
139 memset(props
, 0, sizeof *props
);
141 props
->fw_ver
= dev
->dev
->caps
.fw_ver
;
142 props
->device_cap_flags
= IB_DEVICE_CHANGE_PHY_PORT
|
143 IB_DEVICE_PORT_ACTIVE_EVENT
|
144 IB_DEVICE_SYS_IMAGE_GUID
|
145 IB_DEVICE_RC_RNR_NAK_GEN
|
146 IB_DEVICE_BLOCK_MULTICAST_LOOPBACK
;
147 if (dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR
)
148 props
->device_cap_flags
|= IB_DEVICE_BAD_PKEY_CNTR
;
149 if (dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR
)
150 props
->device_cap_flags
|= IB_DEVICE_BAD_QKEY_CNTR
;
151 if (dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_APM
)
152 props
->device_cap_flags
|= IB_DEVICE_AUTO_PATH_MIG
;
153 if (dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_UD_AV_PORT
)
154 props
->device_cap_flags
|= IB_DEVICE_UD_AV_PORT_ENFORCE
;
155 if (dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_IPOIB_CSUM
)
156 props
->device_cap_flags
|= IB_DEVICE_UD_IP_CSUM
;
157 if (dev
->dev
->caps
.max_gso_sz
&& dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_BLH
)
158 props
->device_cap_flags
|= IB_DEVICE_UD_TSO
;
159 if (dev
->dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_RESERVED_LKEY
)
160 props
->device_cap_flags
|= IB_DEVICE_LOCAL_DMA_LKEY
;
161 if ((dev
->dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_LOCAL_INV
) &&
162 (dev
->dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_REMOTE_INV
) &&
163 (dev
->dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_FAST_REG_WR
))
164 props
->device_cap_flags
|= IB_DEVICE_MEM_MGT_EXTENSIONS
;
165 if (dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_XRC
)
166 props
->device_cap_flags
|= IB_DEVICE_XRC
;
167 if (dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_MEM_WINDOW
)
168 props
->device_cap_flags
|= IB_DEVICE_MEM_WINDOW
;
169 if (dev
->dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_TYPE_2_WIN
) {
170 if (dev
->dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_WIN_TYPE_2B
)
171 props
->device_cap_flags
|= IB_DEVICE_MEM_WINDOW_TYPE_2B
;
173 props
->device_cap_flags
|= IB_DEVICE_MEM_WINDOW_TYPE_2A
;
174 if (dev
->steering_support
== MLX4_STEERING_MODE_DEVICE_MANAGED
)
175 props
->device_cap_flags
|= IB_DEVICE_MANAGED_FLOW_STEERING
;
178 props
->vendor_id
= be32_to_cpup((__be32
*) (out_mad
->data
+ 36)) &
180 props
->vendor_part_id
= dev
->dev
->pdev
->device
;
181 props
->hw_ver
= be32_to_cpup((__be32
*) (out_mad
->data
+ 32));
182 memcpy(&props
->sys_image_guid
, out_mad
->data
+ 4, 8);
184 props
->max_mr_size
= ~0ull;
185 props
->page_size_cap
= dev
->dev
->caps
.page_size_cap
;
186 props
->max_qp
= dev
->dev
->quotas
.qp
;
187 props
->max_qp_wr
= dev
->dev
->caps
.max_wqes
- MLX4_IB_SQ_MAX_SPARE
;
188 props
->max_sge
= min(dev
->dev
->caps
.max_sq_sg
,
189 dev
->dev
->caps
.max_rq_sg
);
190 props
->max_cq
= dev
->dev
->quotas
.cq
;
191 props
->max_cqe
= dev
->dev
->caps
.max_cqes
;
192 props
->max_mr
= dev
->dev
->quotas
.mpt
;
193 props
->max_pd
= dev
->dev
->caps
.num_pds
- dev
->dev
->caps
.reserved_pds
;
194 props
->max_qp_rd_atom
= dev
->dev
->caps
.max_qp_dest_rdma
;
195 props
->max_qp_init_rd_atom
= dev
->dev
->caps
.max_qp_init_rdma
;
196 props
->max_res_rd_atom
= props
->max_qp_rd_atom
* props
->max_qp
;
197 props
->max_srq
= dev
->dev
->quotas
.srq
;
198 props
->max_srq_wr
= dev
->dev
->caps
.max_srq_wqes
- 1;
199 props
->max_srq_sge
= dev
->dev
->caps
.max_srq_sge
;
200 props
->max_fast_reg_page_list_len
= MLX4_MAX_FAST_REG_PAGES
;
201 props
->local_ca_ack_delay
= dev
->dev
->caps
.local_ca_ack_delay
;
202 props
->atomic_cap
= dev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_ATOMIC
?
203 IB_ATOMIC_HCA
: IB_ATOMIC_NONE
;
204 props
->masked_atomic_cap
= props
->atomic_cap
;
205 props
->max_pkeys
= dev
->dev
->caps
.pkey_table_len
[1];
206 props
->max_mcast_grp
= dev
->dev
->caps
.num_mgms
+ dev
->dev
->caps
.num_amgms
;
207 props
->max_mcast_qp_attach
= dev
->dev
->caps
.num_qp_per_mgm
;
208 props
->max_total_mcast_qp_attach
= props
->max_mcast_qp_attach
*
209 props
->max_mcast_grp
;
210 props
->max_map_per_fmr
= dev
->dev
->caps
.max_fmr_maps
;
219 static enum rdma_link_layer
220 mlx4_ib_port_link_layer(struct ib_device
*device
, u8 port_num
)
222 struct mlx4_dev
*dev
= to_mdev(device
)->dev
;
224 return dev
->caps
.port_mask
[port_num
] == MLX4_PORT_TYPE_IB
?
225 IB_LINK_LAYER_INFINIBAND
: IB_LINK_LAYER_ETHERNET
;
228 static int ib_link_query_port(struct ib_device
*ibdev
, u8 port
,
229 struct ib_port_attr
*props
, int netw_view
)
231 struct ib_smp
*in_mad
= NULL
;
232 struct ib_smp
*out_mad
= NULL
;
233 int ext_active_speed
;
234 int mad_ifc_flags
= MLX4_MAD_IFC_IGNORE_KEYS
;
237 in_mad
= kzalloc(sizeof *in_mad
, GFP_KERNEL
);
238 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
239 if (!in_mad
|| !out_mad
)
242 init_query_mad(in_mad
);
243 in_mad
->attr_id
= IB_SMP_ATTR_PORT_INFO
;
244 in_mad
->attr_mod
= cpu_to_be32(port
);
246 if (mlx4_is_mfunc(to_mdev(ibdev
)->dev
) && netw_view
)
247 mad_ifc_flags
|= MLX4_MAD_IFC_NET_VIEW
;
249 err
= mlx4_MAD_IFC(to_mdev(ibdev
), mad_ifc_flags
, port
, NULL
, NULL
,
255 props
->lid
= be16_to_cpup((__be16
*) (out_mad
->data
+ 16));
256 props
->lmc
= out_mad
->data
[34] & 0x7;
257 props
->sm_lid
= be16_to_cpup((__be16
*) (out_mad
->data
+ 18));
258 props
->sm_sl
= out_mad
->data
[36] & 0xf;
259 props
->state
= out_mad
->data
[32] & 0xf;
260 props
->phys_state
= out_mad
->data
[33] >> 4;
261 props
->port_cap_flags
= be32_to_cpup((__be32
*) (out_mad
->data
+ 20));
263 props
->gid_tbl_len
= out_mad
->data
[50];
265 props
->gid_tbl_len
= to_mdev(ibdev
)->dev
->caps
.gid_table_len
[port
];
266 props
->max_msg_sz
= to_mdev(ibdev
)->dev
->caps
.max_msg_sz
;
267 props
->pkey_tbl_len
= to_mdev(ibdev
)->dev
->caps
.pkey_table_len
[port
];
268 props
->bad_pkey_cntr
= be16_to_cpup((__be16
*) (out_mad
->data
+ 46));
269 props
->qkey_viol_cntr
= be16_to_cpup((__be16
*) (out_mad
->data
+ 48));
270 props
->active_width
= out_mad
->data
[31] & 0xf;
271 props
->active_speed
= out_mad
->data
[35] >> 4;
272 props
->max_mtu
= out_mad
->data
[41] & 0xf;
273 props
->active_mtu
= out_mad
->data
[36] >> 4;
274 props
->subnet_timeout
= out_mad
->data
[51] & 0x1f;
275 props
->max_vl_num
= out_mad
->data
[37] >> 4;
276 props
->init_type_reply
= out_mad
->data
[41] >> 4;
278 /* Check if extended speeds (EDR/FDR/...) are supported */
279 if (props
->port_cap_flags
& IB_PORT_EXTENDED_SPEEDS_SUP
) {
280 ext_active_speed
= out_mad
->data
[62] >> 4;
282 switch (ext_active_speed
) {
284 props
->active_speed
= IB_SPEED_FDR
;
287 props
->active_speed
= IB_SPEED_EDR
;
292 /* If reported active speed is QDR, check if is FDR-10 */
293 if (props
->active_speed
== IB_SPEED_QDR
) {
294 init_query_mad(in_mad
);
295 in_mad
->attr_id
= MLX4_ATTR_EXTENDED_PORT_INFO
;
296 in_mad
->attr_mod
= cpu_to_be32(port
);
298 err
= mlx4_MAD_IFC(to_mdev(ibdev
), mad_ifc_flags
, port
,
299 NULL
, NULL
, in_mad
, out_mad
);
303 /* Checking LinkSpeedActive for FDR-10 */
304 if (out_mad
->data
[15] & 0x1)
305 props
->active_speed
= IB_SPEED_FDR10
;
308 /* Avoid wrong speed value returned by FW if the IB link is down. */
309 if (props
->state
== IB_PORT_DOWN
)
310 props
->active_speed
= IB_SPEED_SDR
;
318 static u8
state_to_phys_state(enum ib_port_state state
)
320 return state
== IB_PORT_ACTIVE
? 5 : 3;
323 static int eth_link_query_port(struct ib_device
*ibdev
, u8 port
,
324 struct ib_port_attr
*props
, int netw_view
)
327 struct mlx4_ib_dev
*mdev
= to_mdev(ibdev
);
328 struct mlx4_ib_iboe
*iboe
= &mdev
->iboe
;
329 struct net_device
*ndev
;
331 struct mlx4_cmd_mailbox
*mailbox
;
334 mailbox
= mlx4_alloc_cmd_mailbox(mdev
->dev
);
336 return PTR_ERR(mailbox
);
338 err
= mlx4_cmd_box(mdev
->dev
, 0, mailbox
->dma
, port
, 0,
339 MLX4_CMD_QUERY_PORT
, MLX4_CMD_TIME_CLASS_B
,
344 props
->active_width
= (((u8
*)mailbox
->buf
)[5] == 0x40) ?
345 IB_WIDTH_4X
: IB_WIDTH_1X
;
346 props
->active_speed
= IB_SPEED_QDR
;
347 props
->port_cap_flags
= IB_PORT_CM_SUP
;
348 props
->gid_tbl_len
= mdev
->dev
->caps
.gid_table_len
[port
];
349 props
->max_msg_sz
= mdev
->dev
->caps
.max_msg_sz
;
350 props
->pkey_tbl_len
= 1;
351 props
->max_mtu
= IB_MTU_4096
;
352 props
->max_vl_num
= 2;
353 props
->state
= IB_PORT_DOWN
;
354 props
->phys_state
= state_to_phys_state(props
->state
);
355 props
->active_mtu
= IB_MTU_256
;
356 spin_lock(&iboe
->lock
);
357 ndev
= iboe
->netdevs
[port
- 1];
361 tmp
= iboe_get_mtu(ndev
->mtu
);
362 props
->active_mtu
= tmp
? min(props
->max_mtu
, tmp
) : IB_MTU_256
;
364 props
->state
= (netif_running(ndev
) && netif_carrier_ok(ndev
)) ?
365 IB_PORT_ACTIVE
: IB_PORT_DOWN
;
366 props
->phys_state
= state_to_phys_state(props
->state
);
368 spin_unlock(&iboe
->lock
);
370 mlx4_free_cmd_mailbox(mdev
->dev
, mailbox
);
374 int __mlx4_ib_query_port(struct ib_device
*ibdev
, u8 port
,
375 struct ib_port_attr
*props
, int netw_view
)
379 memset(props
, 0, sizeof *props
);
381 err
= mlx4_ib_port_link_layer(ibdev
, port
) == IB_LINK_LAYER_INFINIBAND
?
382 ib_link_query_port(ibdev
, port
, props
, netw_view
) :
383 eth_link_query_port(ibdev
, port
, props
, netw_view
);
388 static int mlx4_ib_query_port(struct ib_device
*ibdev
, u8 port
,
389 struct ib_port_attr
*props
)
391 /* returns host view */
392 return __mlx4_ib_query_port(ibdev
, port
, props
, 0);
395 int __mlx4_ib_query_gid(struct ib_device
*ibdev
, u8 port
, int index
,
396 union ib_gid
*gid
, int netw_view
)
398 struct ib_smp
*in_mad
= NULL
;
399 struct ib_smp
*out_mad
= NULL
;
401 struct mlx4_ib_dev
*dev
= to_mdev(ibdev
);
403 int mad_ifc_flags
= MLX4_MAD_IFC_IGNORE_KEYS
;
405 in_mad
= kzalloc(sizeof *in_mad
, GFP_KERNEL
);
406 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
407 if (!in_mad
|| !out_mad
)
410 init_query_mad(in_mad
);
411 in_mad
->attr_id
= IB_SMP_ATTR_PORT_INFO
;
412 in_mad
->attr_mod
= cpu_to_be32(port
);
414 if (mlx4_is_mfunc(dev
->dev
) && netw_view
)
415 mad_ifc_flags
|= MLX4_MAD_IFC_NET_VIEW
;
417 err
= mlx4_MAD_IFC(dev
, mad_ifc_flags
, port
, NULL
, NULL
, in_mad
, out_mad
);
421 memcpy(gid
->raw
, out_mad
->data
+ 8, 8);
423 if (mlx4_is_mfunc(dev
->dev
) && !netw_view
) {
425 /* For any index > 0, return the null guid */
432 init_query_mad(in_mad
);
433 in_mad
->attr_id
= IB_SMP_ATTR_GUID_INFO
;
434 in_mad
->attr_mod
= cpu_to_be32(index
/ 8);
436 err
= mlx4_MAD_IFC(dev
, mad_ifc_flags
, port
,
437 NULL
, NULL
, in_mad
, out_mad
);
441 memcpy(gid
->raw
+ 8, out_mad
->data
+ (index
% 8) * 8, 8);
445 memset(gid
->raw
+ 8, 0, 8);
451 static int iboe_query_gid(struct ib_device
*ibdev
, u8 port
, int index
,
454 struct mlx4_ib_dev
*dev
= to_mdev(ibdev
);
456 *gid
= dev
->iboe
.gid_table
[port
- 1][index
];
461 static int mlx4_ib_query_gid(struct ib_device
*ibdev
, u8 port
, int index
,
464 if (rdma_port_get_link_layer(ibdev
, port
) == IB_LINK_LAYER_INFINIBAND
)
465 return __mlx4_ib_query_gid(ibdev
, port
, index
, gid
, 0);
467 return iboe_query_gid(ibdev
, port
, index
, gid
);
470 int __mlx4_ib_query_pkey(struct ib_device
*ibdev
, u8 port
, u16 index
,
471 u16
*pkey
, int netw_view
)
473 struct ib_smp
*in_mad
= NULL
;
474 struct ib_smp
*out_mad
= NULL
;
475 int mad_ifc_flags
= MLX4_MAD_IFC_IGNORE_KEYS
;
478 in_mad
= kzalloc(sizeof *in_mad
, GFP_KERNEL
);
479 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
480 if (!in_mad
|| !out_mad
)
483 init_query_mad(in_mad
);
484 in_mad
->attr_id
= IB_SMP_ATTR_PKEY_TABLE
;
485 in_mad
->attr_mod
= cpu_to_be32(index
/ 32);
487 if (mlx4_is_mfunc(to_mdev(ibdev
)->dev
) && netw_view
)
488 mad_ifc_flags
|= MLX4_MAD_IFC_NET_VIEW
;
490 err
= mlx4_MAD_IFC(to_mdev(ibdev
), mad_ifc_flags
, port
, NULL
, NULL
,
495 *pkey
= be16_to_cpu(((__be16
*) out_mad
->data
)[index
% 32]);
503 static int mlx4_ib_query_pkey(struct ib_device
*ibdev
, u8 port
, u16 index
, u16
*pkey
)
505 return __mlx4_ib_query_pkey(ibdev
, port
, index
, pkey
, 0);
508 static int mlx4_ib_modify_device(struct ib_device
*ibdev
, int mask
,
509 struct ib_device_modify
*props
)
511 struct mlx4_cmd_mailbox
*mailbox
;
514 if (mask
& ~IB_DEVICE_MODIFY_NODE_DESC
)
517 if (!(mask
& IB_DEVICE_MODIFY_NODE_DESC
))
520 if (mlx4_is_slave(to_mdev(ibdev
)->dev
))
523 spin_lock_irqsave(&to_mdev(ibdev
)->sm_lock
, flags
);
524 memcpy(ibdev
->node_desc
, props
->node_desc
, 64);
525 spin_unlock_irqrestore(&to_mdev(ibdev
)->sm_lock
, flags
);
528 * If possible, pass node desc to FW, so it can generate
529 * a 144 trap. If cmd fails, just ignore.
531 mailbox
= mlx4_alloc_cmd_mailbox(to_mdev(ibdev
)->dev
);
535 memcpy(mailbox
->buf
, props
->node_desc
, 64);
536 mlx4_cmd(to_mdev(ibdev
)->dev
, mailbox
->dma
, 1, 0,
537 MLX4_CMD_SET_NODE
, MLX4_CMD_TIME_CLASS_A
, MLX4_CMD_NATIVE
);
539 mlx4_free_cmd_mailbox(to_mdev(ibdev
)->dev
, mailbox
);
544 static int mlx4_SET_PORT(struct mlx4_ib_dev
*dev
, u8 port
, int reset_qkey_viols
,
547 struct mlx4_cmd_mailbox
*mailbox
;
549 u8 is_eth
= dev
->dev
->caps
.port_type
[port
] == MLX4_PORT_TYPE_ETH
;
551 mailbox
= mlx4_alloc_cmd_mailbox(dev
->dev
);
553 return PTR_ERR(mailbox
);
555 if (dev
->dev
->flags
& MLX4_FLAG_OLD_PORT_CMDS
) {
556 *(u8
*) mailbox
->buf
= !!reset_qkey_viols
<< 6;
557 ((__be32
*) mailbox
->buf
)[2] = cpu_to_be32(cap_mask
);
559 ((u8
*) mailbox
->buf
)[3] = !!reset_qkey_viols
;
560 ((__be32
*) mailbox
->buf
)[1] = cpu_to_be32(cap_mask
);
563 err
= mlx4_cmd(dev
->dev
, mailbox
->dma
, port
, is_eth
, MLX4_CMD_SET_PORT
,
564 MLX4_CMD_TIME_CLASS_B
, MLX4_CMD_NATIVE
);
566 mlx4_free_cmd_mailbox(dev
->dev
, mailbox
);
570 static int mlx4_ib_modify_port(struct ib_device
*ibdev
, u8 port
, int mask
,
571 struct ib_port_modify
*props
)
573 struct ib_port_attr attr
;
577 mutex_lock(&to_mdev(ibdev
)->cap_mask_mutex
);
579 err
= mlx4_ib_query_port(ibdev
, port
, &attr
);
583 cap_mask
= (attr
.port_cap_flags
| props
->set_port_cap_mask
) &
584 ~props
->clr_port_cap_mask
;
586 err
= mlx4_SET_PORT(to_mdev(ibdev
), port
,
587 !!(mask
& IB_PORT_RESET_QKEY_CNTR
),
591 mutex_unlock(&to_mdev(ibdev
)->cap_mask_mutex
);
595 static struct ib_ucontext
*mlx4_ib_alloc_ucontext(struct ib_device
*ibdev
,
596 struct ib_udata
*udata
)
598 struct mlx4_ib_dev
*dev
= to_mdev(ibdev
);
599 struct mlx4_ib_ucontext
*context
;
600 struct mlx4_ib_alloc_ucontext_resp_v3 resp_v3
;
601 struct mlx4_ib_alloc_ucontext_resp resp
;
605 return ERR_PTR(-EAGAIN
);
607 if (ibdev
->uverbs_abi_ver
== MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION
) {
608 resp_v3
.qp_tab_size
= dev
->dev
->caps
.num_qps
;
609 resp_v3
.bf_reg_size
= dev
->dev
->caps
.bf_reg_size
;
610 resp_v3
.bf_regs_per_page
= dev
->dev
->caps
.bf_regs_per_page
;
612 resp
.dev_caps
= dev
->dev
->caps
.userspace_caps
;
613 resp
.qp_tab_size
= dev
->dev
->caps
.num_qps
;
614 resp
.bf_reg_size
= dev
->dev
->caps
.bf_reg_size
;
615 resp
.bf_regs_per_page
= dev
->dev
->caps
.bf_regs_per_page
;
616 resp
.cqe_size
= dev
->dev
->caps
.cqe_size
;
619 context
= kmalloc(sizeof *context
, GFP_KERNEL
);
621 return ERR_PTR(-ENOMEM
);
623 err
= mlx4_uar_alloc(to_mdev(ibdev
)->dev
, &context
->uar
);
629 INIT_LIST_HEAD(&context
->db_page_list
);
630 mutex_init(&context
->db_page_mutex
);
632 if (ibdev
->uverbs_abi_ver
== MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION
)
633 err
= ib_copy_to_udata(udata
, &resp_v3
, sizeof(resp_v3
));
635 err
= ib_copy_to_udata(udata
, &resp
, sizeof(resp
));
638 mlx4_uar_free(to_mdev(ibdev
)->dev
, &context
->uar
);
640 return ERR_PTR(-EFAULT
);
643 return &context
->ibucontext
;
646 static int mlx4_ib_dealloc_ucontext(struct ib_ucontext
*ibcontext
)
648 struct mlx4_ib_ucontext
*context
= to_mucontext(ibcontext
);
650 mlx4_uar_free(to_mdev(ibcontext
->device
)->dev
, &context
->uar
);
656 static int mlx4_ib_mmap(struct ib_ucontext
*context
, struct vm_area_struct
*vma
)
658 struct mlx4_ib_dev
*dev
= to_mdev(context
->device
);
660 if (vma
->vm_end
- vma
->vm_start
!= PAGE_SIZE
)
663 if (vma
->vm_pgoff
== 0) {
664 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
666 if (io_remap_pfn_range(vma
, vma
->vm_start
,
667 to_mucontext(context
)->uar
.pfn
,
668 PAGE_SIZE
, vma
->vm_page_prot
))
670 } else if (vma
->vm_pgoff
== 1 && dev
->dev
->caps
.bf_reg_size
!= 0) {
671 vma
->vm_page_prot
= pgprot_writecombine(vma
->vm_page_prot
);
673 if (io_remap_pfn_range(vma
, vma
->vm_start
,
674 to_mucontext(context
)->uar
.pfn
+
675 dev
->dev
->caps
.num_uars
,
676 PAGE_SIZE
, vma
->vm_page_prot
))
684 static struct ib_pd
*mlx4_ib_alloc_pd(struct ib_device
*ibdev
,
685 struct ib_ucontext
*context
,
686 struct ib_udata
*udata
)
688 struct mlx4_ib_pd
*pd
;
691 pd
= kmalloc(sizeof *pd
, GFP_KERNEL
);
693 return ERR_PTR(-ENOMEM
);
695 err
= mlx4_pd_alloc(to_mdev(ibdev
)->dev
, &pd
->pdn
);
702 if (ib_copy_to_udata(udata
, &pd
->pdn
, sizeof (__u32
))) {
703 mlx4_pd_free(to_mdev(ibdev
)->dev
, pd
->pdn
);
705 return ERR_PTR(-EFAULT
);
711 static int mlx4_ib_dealloc_pd(struct ib_pd
*pd
)
713 mlx4_pd_free(to_mdev(pd
->device
)->dev
, to_mpd(pd
)->pdn
);
719 static struct ib_xrcd
*mlx4_ib_alloc_xrcd(struct ib_device
*ibdev
,
720 struct ib_ucontext
*context
,
721 struct ib_udata
*udata
)
723 struct mlx4_ib_xrcd
*xrcd
;
726 if (!(to_mdev(ibdev
)->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_XRC
))
727 return ERR_PTR(-ENOSYS
);
729 xrcd
= kmalloc(sizeof *xrcd
, GFP_KERNEL
);
731 return ERR_PTR(-ENOMEM
);
733 err
= mlx4_xrcd_alloc(to_mdev(ibdev
)->dev
, &xrcd
->xrcdn
);
737 xrcd
->pd
= ib_alloc_pd(ibdev
);
738 if (IS_ERR(xrcd
->pd
)) {
739 err
= PTR_ERR(xrcd
->pd
);
743 xrcd
->cq
= ib_create_cq(ibdev
, NULL
, NULL
, xrcd
, 1, 0);
744 if (IS_ERR(xrcd
->cq
)) {
745 err
= PTR_ERR(xrcd
->cq
);
749 return &xrcd
->ibxrcd
;
752 ib_dealloc_pd(xrcd
->pd
);
754 mlx4_xrcd_free(to_mdev(ibdev
)->dev
, xrcd
->xrcdn
);
760 static int mlx4_ib_dealloc_xrcd(struct ib_xrcd
*xrcd
)
762 ib_destroy_cq(to_mxrcd(xrcd
)->cq
);
763 ib_dealloc_pd(to_mxrcd(xrcd
)->pd
);
764 mlx4_xrcd_free(to_mdev(xrcd
->device
)->dev
, to_mxrcd(xrcd
)->xrcdn
);
770 static int add_gid_entry(struct ib_qp
*ibqp
, union ib_gid
*gid
)
772 struct mlx4_ib_qp
*mqp
= to_mqp(ibqp
);
773 struct mlx4_ib_dev
*mdev
= to_mdev(ibqp
->device
);
774 struct mlx4_ib_gid_entry
*ge
;
776 ge
= kzalloc(sizeof *ge
, GFP_KERNEL
);
781 if (mlx4_ib_add_mc(mdev
, mqp
, gid
)) {
782 ge
->port
= mqp
->port
;
786 mutex_lock(&mqp
->mutex
);
787 list_add_tail(&ge
->list
, &mqp
->gid_list
);
788 mutex_unlock(&mqp
->mutex
);
793 int mlx4_ib_add_mc(struct mlx4_ib_dev
*mdev
, struct mlx4_ib_qp
*mqp
,
797 struct net_device
*ndev
;
803 spin_lock(&mdev
->iboe
.lock
);
804 ndev
= mdev
->iboe
.netdevs
[mqp
->port
- 1];
807 spin_unlock(&mdev
->iboe
.lock
);
810 rdma_get_mcast_mac((struct in6_addr
*)gid
, mac
);
812 dev_mc_add(mdev
->iboe
.netdevs
[mqp
->port
- 1], mac
);
821 struct mlx4_ib_steering
{
822 struct list_head list
;
827 static int parse_flow_attr(struct mlx4_dev
*dev
,
828 union ib_flow_spec
*ib_spec
,
829 struct _rule_hw
*mlx4_spec
)
831 enum mlx4_net_trans_rule_id type
;
833 switch (ib_spec
->type
) {
834 case IB_FLOW_SPEC_ETH
:
835 type
= MLX4_NET_TRANS_RULE_ID_ETH
;
836 memcpy(mlx4_spec
->eth
.dst_mac
, ib_spec
->eth
.val
.dst_mac
,
838 memcpy(mlx4_spec
->eth
.dst_mac_msk
, ib_spec
->eth
.mask
.dst_mac
,
840 mlx4_spec
->eth
.vlan_tag
= ib_spec
->eth
.val
.vlan_tag
;
841 mlx4_spec
->eth
.vlan_tag_msk
= ib_spec
->eth
.mask
.vlan_tag
;
844 case IB_FLOW_SPEC_IPV4
:
845 type
= MLX4_NET_TRANS_RULE_ID_IPV4
;
846 mlx4_spec
->ipv4
.src_ip
= ib_spec
->ipv4
.val
.src_ip
;
847 mlx4_spec
->ipv4
.src_ip_msk
= ib_spec
->ipv4
.mask
.src_ip
;
848 mlx4_spec
->ipv4
.dst_ip
= ib_spec
->ipv4
.val
.dst_ip
;
849 mlx4_spec
->ipv4
.dst_ip_msk
= ib_spec
->ipv4
.mask
.dst_ip
;
852 case IB_FLOW_SPEC_TCP
:
853 case IB_FLOW_SPEC_UDP
:
854 type
= ib_spec
->type
== IB_FLOW_SPEC_TCP
?
855 MLX4_NET_TRANS_RULE_ID_TCP
:
856 MLX4_NET_TRANS_RULE_ID_UDP
;
857 mlx4_spec
->tcp_udp
.dst_port
= ib_spec
->tcp_udp
.val
.dst_port
;
858 mlx4_spec
->tcp_udp
.dst_port_msk
= ib_spec
->tcp_udp
.mask
.dst_port
;
859 mlx4_spec
->tcp_udp
.src_port
= ib_spec
->tcp_udp
.val
.src_port
;
860 mlx4_spec
->tcp_udp
.src_port_msk
= ib_spec
->tcp_udp
.mask
.src_port
;
866 if (mlx4_map_sw_to_hw_steering_id(dev
, type
) < 0 ||
867 mlx4_hw_rule_sz(dev
, type
) < 0)
869 mlx4_spec
->id
= cpu_to_be16(mlx4_map_sw_to_hw_steering_id(dev
, type
));
870 mlx4_spec
->size
= mlx4_hw_rule_sz(dev
, type
) >> 2;
871 return mlx4_hw_rule_sz(dev
, type
);
874 static int __mlx4_ib_create_flow(struct ib_qp
*qp
, struct ib_flow_attr
*flow_attr
,
876 enum mlx4_net_trans_promisc_mode flow_type
,
882 struct mlx4_ib_dev
*mdev
= to_mdev(qp
->device
);
883 struct mlx4_cmd_mailbox
*mailbox
;
884 struct mlx4_net_trans_rule_hw_ctrl
*ctrl
;
886 static const u16 __mlx4_domain
[] = {
887 [IB_FLOW_DOMAIN_USER
] = MLX4_DOMAIN_UVERBS
,
888 [IB_FLOW_DOMAIN_ETHTOOL
] = MLX4_DOMAIN_ETHTOOL
,
889 [IB_FLOW_DOMAIN_RFS
] = MLX4_DOMAIN_RFS
,
890 [IB_FLOW_DOMAIN_NIC
] = MLX4_DOMAIN_NIC
,
893 if (flow_attr
->priority
> MLX4_IB_FLOW_MAX_PRIO
) {
894 pr_err("Invalid priority value %d\n", flow_attr
->priority
);
898 if (domain
>= IB_FLOW_DOMAIN_NUM
) {
899 pr_err("Invalid domain value %d\n", domain
);
903 if (mlx4_map_sw_to_hw_steering_mode(mdev
->dev
, flow_type
) < 0)
906 mailbox
= mlx4_alloc_cmd_mailbox(mdev
->dev
);
908 return PTR_ERR(mailbox
);
911 ctrl
->prio
= cpu_to_be16(__mlx4_domain
[domain
] |
912 flow_attr
->priority
);
913 ctrl
->type
= mlx4_map_sw_to_hw_steering_mode(mdev
->dev
, flow_type
);
914 ctrl
->port
= flow_attr
->port
;
915 ctrl
->qpn
= cpu_to_be32(qp
->qp_num
);
917 ib_flow
= flow_attr
+ 1;
918 size
+= sizeof(struct mlx4_net_trans_rule_hw_ctrl
);
919 for (i
= 0; i
< flow_attr
->num_of_specs
; i
++) {
920 ret
= parse_flow_attr(mdev
->dev
, ib_flow
, mailbox
->buf
+ size
);
922 mlx4_free_cmd_mailbox(mdev
->dev
, mailbox
);
925 ib_flow
+= ((union ib_flow_spec
*) ib_flow
)->size
;
929 ret
= mlx4_cmd_imm(mdev
->dev
, mailbox
->dma
, reg_id
, size
>> 2, 0,
930 MLX4_QP_FLOW_STEERING_ATTACH
, MLX4_CMD_TIME_CLASS_A
,
933 pr_err("mcg table is full. Fail to register network rule.\n");
934 else if (ret
== -ENXIO
)
935 pr_err("Device managed flow steering is disabled. Fail to register network rule.\n");
937 pr_err("Invalid argumant. Fail to register network rule.\n");
939 mlx4_free_cmd_mailbox(mdev
->dev
, mailbox
);
943 static int __mlx4_ib_destroy_flow(struct mlx4_dev
*dev
, u64 reg_id
)
946 err
= mlx4_cmd(dev
, reg_id
, 0, 0,
947 MLX4_QP_FLOW_STEERING_DETACH
, MLX4_CMD_TIME_CLASS_A
,
950 pr_err("Fail to detach network rule. registration id = 0x%llx\n",
955 static struct ib_flow
*mlx4_ib_create_flow(struct ib_qp
*qp
,
956 struct ib_flow_attr
*flow_attr
,
960 struct mlx4_ib_flow
*mflow
;
961 enum mlx4_net_trans_promisc_mode type
[2];
963 memset(type
, 0, sizeof(type
));
965 mflow
= kzalloc(sizeof(*mflow
), GFP_KERNEL
);
971 switch (flow_attr
->type
) {
972 case IB_FLOW_ATTR_NORMAL
:
973 type
[0] = MLX4_FS_REGULAR
;
976 case IB_FLOW_ATTR_ALL_DEFAULT
:
977 type
[0] = MLX4_FS_ALL_DEFAULT
;
980 case IB_FLOW_ATTR_MC_DEFAULT
:
981 type
[0] = MLX4_FS_MC_DEFAULT
;
984 case IB_FLOW_ATTR_SNIFFER
:
985 type
[0] = MLX4_FS_UC_SNIFFER
;
986 type
[1] = MLX4_FS_MC_SNIFFER
;
994 while (i
< ARRAY_SIZE(type
) && type
[i
]) {
995 err
= __mlx4_ib_create_flow(qp
, flow_attr
, domain
, type
[i
],
1002 return &mflow
->ibflow
;
1006 return ERR_PTR(err
);
1009 static int mlx4_ib_destroy_flow(struct ib_flow
*flow_id
)
1013 struct mlx4_ib_dev
*mdev
= to_mdev(flow_id
->qp
->device
);
1014 struct mlx4_ib_flow
*mflow
= to_mflow(flow_id
);
1016 while (i
< ARRAY_SIZE(mflow
->reg_id
) && mflow
->reg_id
[i
]) {
1017 err
= __mlx4_ib_destroy_flow(mdev
->dev
, mflow
->reg_id
[i
]);
1027 static int mlx4_ib_mcg_attach(struct ib_qp
*ibqp
, union ib_gid
*gid
, u16 lid
)
1030 struct mlx4_ib_dev
*mdev
= to_mdev(ibqp
->device
);
1031 struct mlx4_ib_qp
*mqp
= to_mqp(ibqp
);
1033 struct mlx4_ib_steering
*ib_steering
= NULL
;
1035 if (mdev
->dev
->caps
.steering_mode
==
1036 MLX4_STEERING_MODE_DEVICE_MANAGED
) {
1037 ib_steering
= kmalloc(sizeof(*ib_steering
), GFP_KERNEL
);
1042 err
= mlx4_multicast_attach(mdev
->dev
, &mqp
->mqp
, gid
->raw
, mqp
->port
,
1044 MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK
),
1045 MLX4_PROT_IB_IPV6
, ®_id
);
1049 err
= add_gid_entry(ibqp
, gid
);
1054 memcpy(ib_steering
->gid
.raw
, gid
->raw
, 16);
1055 ib_steering
->reg_id
= reg_id
;
1056 mutex_lock(&mqp
->mutex
);
1057 list_add(&ib_steering
->list
, &mqp
->steering_rules
);
1058 mutex_unlock(&mqp
->mutex
);
1063 mlx4_multicast_detach(mdev
->dev
, &mqp
->mqp
, gid
->raw
,
1064 MLX4_PROT_IB_IPV6
, reg_id
);
1071 static struct mlx4_ib_gid_entry
*find_gid_entry(struct mlx4_ib_qp
*qp
, u8
*raw
)
1073 struct mlx4_ib_gid_entry
*ge
;
1074 struct mlx4_ib_gid_entry
*tmp
;
1075 struct mlx4_ib_gid_entry
*ret
= NULL
;
1077 list_for_each_entry_safe(ge
, tmp
, &qp
->gid_list
, list
) {
1078 if (!memcmp(raw
, ge
->gid
.raw
, 16)) {
1087 static int mlx4_ib_mcg_detach(struct ib_qp
*ibqp
, union ib_gid
*gid
, u16 lid
)
1090 struct mlx4_ib_dev
*mdev
= to_mdev(ibqp
->device
);
1091 struct mlx4_ib_qp
*mqp
= to_mqp(ibqp
);
1093 struct net_device
*ndev
;
1094 struct mlx4_ib_gid_entry
*ge
;
1097 if (mdev
->dev
->caps
.steering_mode
==
1098 MLX4_STEERING_MODE_DEVICE_MANAGED
) {
1099 struct mlx4_ib_steering
*ib_steering
;
1101 mutex_lock(&mqp
->mutex
);
1102 list_for_each_entry(ib_steering
, &mqp
->steering_rules
, list
) {
1103 if (!memcmp(ib_steering
->gid
.raw
, gid
->raw
, 16)) {
1104 list_del(&ib_steering
->list
);
1108 mutex_unlock(&mqp
->mutex
);
1109 if (&ib_steering
->list
== &mqp
->steering_rules
) {
1110 pr_err("Couldn't find reg_id for mgid. Steering rule is left attached\n");
1113 reg_id
= ib_steering
->reg_id
;
1117 err
= mlx4_multicast_detach(mdev
->dev
, &mqp
->mqp
, gid
->raw
,
1118 MLX4_PROT_IB_IPV6
, reg_id
);
1122 mutex_lock(&mqp
->mutex
);
1123 ge
= find_gid_entry(mqp
, gid
->raw
);
1125 spin_lock(&mdev
->iboe
.lock
);
1126 ndev
= ge
->added
? mdev
->iboe
.netdevs
[ge
->port
- 1] : NULL
;
1129 spin_unlock(&mdev
->iboe
.lock
);
1130 rdma_get_mcast_mac((struct in6_addr
*)gid
, mac
);
1133 dev_mc_del(mdev
->iboe
.netdevs
[ge
->port
- 1], mac
);
1137 list_del(&ge
->list
);
1140 pr_warn("could not find mgid entry\n");
1142 mutex_unlock(&mqp
->mutex
);
1147 static int init_node_data(struct mlx4_ib_dev
*dev
)
1149 struct ib_smp
*in_mad
= NULL
;
1150 struct ib_smp
*out_mad
= NULL
;
1151 int mad_ifc_flags
= MLX4_MAD_IFC_IGNORE_KEYS
;
1154 in_mad
= kzalloc(sizeof *in_mad
, GFP_KERNEL
);
1155 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
1156 if (!in_mad
|| !out_mad
)
1159 init_query_mad(in_mad
);
1160 in_mad
->attr_id
= IB_SMP_ATTR_NODE_DESC
;
1161 if (mlx4_is_master(dev
->dev
))
1162 mad_ifc_flags
|= MLX4_MAD_IFC_NET_VIEW
;
1164 err
= mlx4_MAD_IFC(dev
, mad_ifc_flags
, 1, NULL
, NULL
, in_mad
, out_mad
);
1168 memcpy(dev
->ib_dev
.node_desc
, out_mad
->data
, 64);
1170 in_mad
->attr_id
= IB_SMP_ATTR_NODE_INFO
;
1172 err
= mlx4_MAD_IFC(dev
, mad_ifc_flags
, 1, NULL
, NULL
, in_mad
, out_mad
);
1176 dev
->dev
->rev_id
= be32_to_cpup((__be32
*) (out_mad
->data
+ 32));
1177 memcpy(&dev
->ib_dev
.node_guid
, out_mad
->data
+ 12, 8);
1185 static ssize_t
show_hca(struct device
*device
, struct device_attribute
*attr
,
1188 struct mlx4_ib_dev
*dev
=
1189 container_of(device
, struct mlx4_ib_dev
, ib_dev
.dev
);
1190 return sprintf(buf
, "MT%d\n", dev
->dev
->pdev
->device
);
1193 static ssize_t
show_fw_ver(struct device
*device
, struct device_attribute
*attr
,
1196 struct mlx4_ib_dev
*dev
=
1197 container_of(device
, struct mlx4_ib_dev
, ib_dev
.dev
);
1198 return sprintf(buf
, "%d.%d.%d\n", (int) (dev
->dev
->caps
.fw_ver
>> 32),
1199 (int) (dev
->dev
->caps
.fw_ver
>> 16) & 0xffff,
1200 (int) dev
->dev
->caps
.fw_ver
& 0xffff);
1203 static ssize_t
show_rev(struct device
*device
, struct device_attribute
*attr
,
1206 struct mlx4_ib_dev
*dev
=
1207 container_of(device
, struct mlx4_ib_dev
, ib_dev
.dev
);
1208 return sprintf(buf
, "%x\n", dev
->dev
->rev_id
);
1211 static ssize_t
show_board(struct device
*device
, struct device_attribute
*attr
,
1214 struct mlx4_ib_dev
*dev
=
1215 container_of(device
, struct mlx4_ib_dev
, ib_dev
.dev
);
1216 return sprintf(buf
, "%.*s\n", MLX4_BOARD_ID_LEN
,
1217 dev
->dev
->board_id
);
1220 static DEVICE_ATTR(hw_rev
, S_IRUGO
, show_rev
, NULL
);
1221 static DEVICE_ATTR(fw_ver
, S_IRUGO
, show_fw_ver
, NULL
);
1222 static DEVICE_ATTR(hca_type
, S_IRUGO
, show_hca
, NULL
);
1223 static DEVICE_ATTR(board_id
, S_IRUGO
, show_board
, NULL
);
1225 static struct device_attribute
*mlx4_class_attributes
[] = {
1232 static void mlx4_addrconf_ifid_eui48(u8
*eui
, u16 vlan_id
, struct net_device
*dev
)
1234 memcpy(eui
, dev
->dev_addr
, 3);
1235 memcpy(eui
+ 5, dev
->dev_addr
+ 3, 3);
1236 if (vlan_id
< 0x1000) {
1237 eui
[3] = vlan_id
>> 8;
1238 eui
[4] = vlan_id
& 0xff;
1246 static void update_gids_task(struct work_struct
*work
)
1248 struct update_gid_work
*gw
= container_of(work
, struct update_gid_work
, work
);
1249 struct mlx4_cmd_mailbox
*mailbox
;
1252 struct mlx4_dev
*dev
= gw
->dev
->dev
;
1254 mailbox
= mlx4_alloc_cmd_mailbox(dev
);
1255 if (IS_ERR(mailbox
)) {
1256 pr_warn("update gid table failed %ld\n", PTR_ERR(mailbox
));
1260 gids
= mailbox
->buf
;
1261 memcpy(gids
, gw
->gids
, sizeof gw
->gids
);
1263 err
= mlx4_cmd(dev
, mailbox
->dma
, MLX4_SET_PORT_GID_TABLE
<< 8 | gw
->port
,
1264 1, MLX4_CMD_SET_PORT
, MLX4_CMD_TIME_CLASS_B
,
1267 pr_warn("set port command failed\n");
1269 memcpy(gw
->dev
->iboe
.gid_table
[gw
->port
- 1], gw
->gids
, sizeof gw
->gids
);
1270 mlx4_ib_dispatch_event(gw
->dev
, gw
->port
, IB_EVENT_GID_CHANGE
);
1273 mlx4_free_cmd_mailbox(dev
, mailbox
);
1277 static int update_ipv6_gids(struct mlx4_ib_dev
*dev
, int port
, int clear
)
1279 struct net_device
*ndev
= dev
->iboe
.netdevs
[port
- 1];
1280 struct update_gid_work
*work
;
1281 struct net_device
*tmp
;
1288 int need_update
= 0;
1291 work
= kzalloc(sizeof *work
, GFP_ATOMIC
);
1295 hits
= kzalloc(128, GFP_ATOMIC
);
1302 for_each_netdev_rcu(&init_net
, tmp
) {
1303 if (ndev
&& (tmp
== ndev
|| rdma_vlan_dev_real_dev(tmp
) == ndev
)) {
1304 gid
.global
.subnet_prefix
= cpu_to_be64(0xfe80000000000000LL
);
1305 vid
= rdma_vlan_dev_vlan_id(tmp
);
1306 mlx4_addrconf_ifid_eui48(&gid
.raw
[8], vid
, ndev
);
1309 for (i
= 0; i
< 128; ++i
) {
1311 !memcmp(&dev
->iboe
.gid_table
[port
- 1][i
], &zgid
, sizeof zgid
))
1313 if (!memcmp(&dev
->iboe
.gid_table
[port
- 1][i
], &gid
, sizeof gid
)) {
1322 (memcmp(&dev
->iboe
.gid_table
[port
- 1][0],
1323 &gid
, sizeof gid
) ||
1324 !memcmp(&dev
->iboe
.gid_table
[port
- 1][0],
1325 &zgid
, sizeof gid
))) {
1326 dev
->iboe
.gid_table
[port
- 1][0] = gid
;
1329 } else if (free
>= 0) {
1330 dev
->iboe
.gid_table
[port
- 1][free
] = gid
;
1339 for (i
= 0; i
< 128; ++i
)
1341 if (memcmp(&dev
->iboe
.gid_table
[port
- 1][i
], &zgid
, sizeof zgid
))
1343 dev
->iboe
.gid_table
[port
- 1][i
] = zgid
;
1347 memcpy(work
->gids
, dev
->iboe
.gid_table
[port
- 1], sizeof work
->gids
);
1348 INIT_WORK(&work
->work
, update_gids_task
);
1351 queue_work(wq
, &work
->work
);
1363 static void handle_en_event(struct mlx4_ib_dev
*dev
, int port
, unsigned long event
)
1367 case NETDEV_CHANGEADDR
:
1368 update_ipv6_gids(dev
, port
, 0);
1372 update_ipv6_gids(dev
, port
, 1);
1373 dev
->iboe
.netdevs
[port
- 1] = NULL
;
1377 static void netdev_added(struct mlx4_ib_dev
*dev
, int port
)
1379 update_ipv6_gids(dev
, port
, 0);
1382 static void netdev_removed(struct mlx4_ib_dev
*dev
, int port
)
1384 update_ipv6_gids(dev
, port
, 1);
1387 static int mlx4_ib_netdev_event(struct notifier_block
*this, unsigned long event
,
1390 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1391 struct mlx4_ib_dev
*ibdev
;
1392 struct net_device
*oldnd
;
1393 struct mlx4_ib_iboe
*iboe
;
1396 if (!net_eq(dev_net(dev
), &init_net
))
1399 ibdev
= container_of(this, struct mlx4_ib_dev
, iboe
.nb
);
1400 iboe
= &ibdev
->iboe
;
1402 spin_lock(&iboe
->lock
);
1403 mlx4_foreach_ib_transport_port(port
, ibdev
->dev
) {
1404 oldnd
= iboe
->netdevs
[port
- 1];
1405 iboe
->netdevs
[port
- 1] =
1406 mlx4_get_protocol_dev(ibdev
->dev
, MLX4_PROT_ETH
, port
);
1407 if (oldnd
!= iboe
->netdevs
[port
- 1]) {
1408 if (iboe
->netdevs
[port
- 1])
1409 netdev_added(ibdev
, port
);
1411 netdev_removed(ibdev
, port
);
1415 if (dev
== iboe
->netdevs
[0] ||
1416 (iboe
->netdevs
[0] && rdma_vlan_dev_real_dev(dev
) == iboe
->netdevs
[0]))
1417 handle_en_event(ibdev
, 1, event
);
1418 else if (dev
== iboe
->netdevs
[1]
1419 || (iboe
->netdevs
[1] && rdma_vlan_dev_real_dev(dev
) == iboe
->netdevs
[1]))
1420 handle_en_event(ibdev
, 2, event
);
1422 spin_unlock(&iboe
->lock
);
1427 static void init_pkeys(struct mlx4_ib_dev
*ibdev
)
1433 if (mlx4_is_master(ibdev
->dev
)) {
1434 for (slave
= 0; slave
<= ibdev
->dev
->num_vfs
; ++slave
) {
1435 for (port
= 1; port
<= ibdev
->dev
->caps
.num_ports
; ++port
) {
1437 i
< ibdev
->dev
->phys_caps
.pkey_phys_table_len
[port
];
1439 ibdev
->pkeys
.virt2phys_pkey
[slave
][port
- 1][i
] =
1440 /* master has the identity virt2phys pkey mapping */
1441 (slave
== mlx4_master_func_num(ibdev
->dev
) || !i
) ? i
:
1442 ibdev
->dev
->phys_caps
.pkey_phys_table_len
[port
] - 1;
1443 mlx4_sync_pkey_table(ibdev
->dev
, slave
, port
, i
,
1444 ibdev
->pkeys
.virt2phys_pkey
[slave
][port
- 1][i
]);
1448 /* initialize pkey cache */
1449 for (port
= 1; port
<= ibdev
->dev
->caps
.num_ports
; ++port
) {
1451 i
< ibdev
->dev
->phys_caps
.pkey_phys_table_len
[port
];
1453 ibdev
->pkeys
.phys_pkey_cache
[port
-1][i
] =
1459 static void mlx4_ib_alloc_eqs(struct mlx4_dev
*dev
, struct mlx4_ib_dev
*ibdev
)
1462 int eq_per_port
= 0;
1467 /* Legacy mode or comp_pool is not large enough */
1468 if (dev
->caps
.comp_pool
== 0 ||
1469 dev
->caps
.num_ports
> dev
->caps
.comp_pool
)
1472 eq_per_port
= rounddown_pow_of_two(dev
->caps
.comp_pool
/
1473 dev
->caps
.num_ports
);
1477 mlx4_foreach_port(i
, dev
, MLX4_PORT_TYPE_IB
)
1478 added_eqs
+= eq_per_port
;
1480 total_eqs
= dev
->caps
.num_comp_vectors
+ added_eqs
;
1482 ibdev
->eq_table
= kzalloc(total_eqs
* sizeof(int), GFP_KERNEL
);
1483 if (!ibdev
->eq_table
)
1486 ibdev
->eq_added
= added_eqs
;
1489 mlx4_foreach_port(i
, dev
, MLX4_PORT_TYPE_IB
) {
1490 for (j
= 0; j
< eq_per_port
; j
++) {
1491 sprintf(name
, "mlx4-ib-%d-%d@%s",
1492 i
, j
, dev
->pdev
->bus
->name
);
1493 /* Set IRQ for specific name (per ring) */
1494 if (mlx4_assign_eq(dev
, name
, NULL
,
1495 &ibdev
->eq_table
[eq
])) {
1496 /* Use legacy (same as mlx4_en driver) */
1497 pr_warn("Can't allocate EQ %d; reverting to legacy\n", eq
);
1498 ibdev
->eq_table
[eq
] =
1499 (eq
% dev
->caps
.num_comp_vectors
);
1505 /* Fill the reset of the vector with legacy EQ */
1506 for (i
= 0, eq
= added_eqs
; i
< dev
->caps
.num_comp_vectors
; i
++)
1507 ibdev
->eq_table
[eq
++] = i
;
1509 /* Advertise the new number of EQs to clients */
1510 ibdev
->ib_dev
.num_comp_vectors
= total_eqs
;
1513 static void mlx4_ib_free_eqs(struct mlx4_dev
*dev
, struct mlx4_ib_dev
*ibdev
)
1517 /* no additional eqs were added */
1518 if (!ibdev
->eq_table
)
1521 /* Reset the advertised EQ number */
1522 ibdev
->ib_dev
.num_comp_vectors
= dev
->caps
.num_comp_vectors
;
1524 /* Free only the added eqs */
1525 for (i
= 0; i
< ibdev
->eq_added
; i
++) {
1526 /* Don't free legacy eqs if used */
1527 if (ibdev
->eq_table
[i
] <= dev
->caps
.num_comp_vectors
)
1529 mlx4_release_eq(dev
, ibdev
->eq_table
[i
]);
1532 kfree(ibdev
->eq_table
);
1535 static void *mlx4_ib_add(struct mlx4_dev
*dev
)
1537 struct mlx4_ib_dev
*ibdev
;
1541 struct mlx4_ib_iboe
*iboe
;
1543 pr_info_once("%s", mlx4_ib_version
);
1545 mlx4_foreach_non_ib_transport_port(i
, dev
)
1548 if (mlx4_is_mfunc(dev
) && num_ports
) {
1549 dev_err(&dev
->pdev
->dev
, "RoCE is not supported over SRIOV as yet\n");
1554 mlx4_foreach_ib_transport_port(i
, dev
)
1557 /* No point in registering a device with no ports... */
1561 ibdev
= (struct mlx4_ib_dev
*) ib_alloc_device(sizeof *ibdev
);
1563 dev_err(&dev
->pdev
->dev
, "Device struct alloc failed\n");
1567 iboe
= &ibdev
->iboe
;
1569 if (mlx4_pd_alloc(dev
, &ibdev
->priv_pdn
))
1572 if (mlx4_uar_alloc(dev
, &ibdev
->priv_uar
))
1575 ibdev
->uar_map
= ioremap((phys_addr_t
) ibdev
->priv_uar
.pfn
<< PAGE_SHIFT
,
1577 if (!ibdev
->uar_map
)
1579 MLX4_INIT_DOORBELL_LOCK(&ibdev
->uar_lock
);
1583 strlcpy(ibdev
->ib_dev
.name
, "mlx4_%d", IB_DEVICE_NAME_MAX
);
1584 ibdev
->ib_dev
.owner
= THIS_MODULE
;
1585 ibdev
->ib_dev
.node_type
= RDMA_NODE_IB_CA
;
1586 ibdev
->ib_dev
.local_dma_lkey
= dev
->caps
.reserved_lkey
;
1587 ibdev
->num_ports
= num_ports
;
1588 ibdev
->ib_dev
.phys_port_cnt
= ibdev
->num_ports
;
1589 ibdev
->ib_dev
.num_comp_vectors
= dev
->caps
.num_comp_vectors
;
1590 ibdev
->ib_dev
.dma_device
= &dev
->pdev
->dev
;
1592 if (dev
->caps
.userspace_caps
)
1593 ibdev
->ib_dev
.uverbs_abi_ver
= MLX4_IB_UVERBS_ABI_VERSION
;
1595 ibdev
->ib_dev
.uverbs_abi_ver
= MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION
;
1597 ibdev
->ib_dev
.uverbs_cmd_mask
=
1598 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT
) |
1599 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE
) |
1600 (1ull << IB_USER_VERBS_CMD_QUERY_PORT
) |
1601 (1ull << IB_USER_VERBS_CMD_ALLOC_PD
) |
1602 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD
) |
1603 (1ull << IB_USER_VERBS_CMD_REG_MR
) |
1604 (1ull << IB_USER_VERBS_CMD_DEREG_MR
) |
1605 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL
) |
1606 (1ull << IB_USER_VERBS_CMD_CREATE_CQ
) |
1607 (1ull << IB_USER_VERBS_CMD_RESIZE_CQ
) |
1608 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ
) |
1609 (1ull << IB_USER_VERBS_CMD_CREATE_QP
) |
1610 (1ull << IB_USER_VERBS_CMD_MODIFY_QP
) |
1611 (1ull << IB_USER_VERBS_CMD_QUERY_QP
) |
1612 (1ull << IB_USER_VERBS_CMD_DESTROY_QP
) |
1613 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST
) |
1614 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST
) |
1615 (1ull << IB_USER_VERBS_CMD_CREATE_SRQ
) |
1616 (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ
) |
1617 (1ull << IB_USER_VERBS_CMD_QUERY_SRQ
) |
1618 (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ
) |
1619 (1ull << IB_USER_VERBS_CMD_CREATE_XSRQ
) |
1620 (1ull << IB_USER_VERBS_CMD_OPEN_QP
);
1622 ibdev
->ib_dev
.query_device
= mlx4_ib_query_device
;
1623 ibdev
->ib_dev
.query_port
= mlx4_ib_query_port
;
1624 ibdev
->ib_dev
.get_link_layer
= mlx4_ib_port_link_layer
;
1625 ibdev
->ib_dev
.query_gid
= mlx4_ib_query_gid
;
1626 ibdev
->ib_dev
.query_pkey
= mlx4_ib_query_pkey
;
1627 ibdev
->ib_dev
.modify_device
= mlx4_ib_modify_device
;
1628 ibdev
->ib_dev
.modify_port
= mlx4_ib_modify_port
;
1629 ibdev
->ib_dev
.alloc_ucontext
= mlx4_ib_alloc_ucontext
;
1630 ibdev
->ib_dev
.dealloc_ucontext
= mlx4_ib_dealloc_ucontext
;
1631 ibdev
->ib_dev
.mmap
= mlx4_ib_mmap
;
1632 ibdev
->ib_dev
.alloc_pd
= mlx4_ib_alloc_pd
;
1633 ibdev
->ib_dev
.dealloc_pd
= mlx4_ib_dealloc_pd
;
1634 ibdev
->ib_dev
.create_ah
= mlx4_ib_create_ah
;
1635 ibdev
->ib_dev
.query_ah
= mlx4_ib_query_ah
;
1636 ibdev
->ib_dev
.destroy_ah
= mlx4_ib_destroy_ah
;
1637 ibdev
->ib_dev
.create_srq
= mlx4_ib_create_srq
;
1638 ibdev
->ib_dev
.modify_srq
= mlx4_ib_modify_srq
;
1639 ibdev
->ib_dev
.query_srq
= mlx4_ib_query_srq
;
1640 ibdev
->ib_dev
.destroy_srq
= mlx4_ib_destroy_srq
;
1641 ibdev
->ib_dev
.post_srq_recv
= mlx4_ib_post_srq_recv
;
1642 ibdev
->ib_dev
.create_qp
= mlx4_ib_create_qp
;
1643 ibdev
->ib_dev
.modify_qp
= mlx4_ib_modify_qp
;
1644 ibdev
->ib_dev
.query_qp
= mlx4_ib_query_qp
;
1645 ibdev
->ib_dev
.destroy_qp
= mlx4_ib_destroy_qp
;
1646 ibdev
->ib_dev
.post_send
= mlx4_ib_post_send
;
1647 ibdev
->ib_dev
.post_recv
= mlx4_ib_post_recv
;
1648 ibdev
->ib_dev
.create_cq
= mlx4_ib_create_cq
;
1649 ibdev
->ib_dev
.modify_cq
= mlx4_ib_modify_cq
;
1650 ibdev
->ib_dev
.resize_cq
= mlx4_ib_resize_cq
;
1651 ibdev
->ib_dev
.destroy_cq
= mlx4_ib_destroy_cq
;
1652 ibdev
->ib_dev
.poll_cq
= mlx4_ib_poll_cq
;
1653 ibdev
->ib_dev
.req_notify_cq
= mlx4_ib_arm_cq
;
1654 ibdev
->ib_dev
.get_dma_mr
= mlx4_ib_get_dma_mr
;
1655 ibdev
->ib_dev
.reg_user_mr
= mlx4_ib_reg_user_mr
;
1656 ibdev
->ib_dev
.dereg_mr
= mlx4_ib_dereg_mr
;
1657 ibdev
->ib_dev
.alloc_fast_reg_mr
= mlx4_ib_alloc_fast_reg_mr
;
1658 ibdev
->ib_dev
.alloc_fast_reg_page_list
= mlx4_ib_alloc_fast_reg_page_list
;
1659 ibdev
->ib_dev
.free_fast_reg_page_list
= mlx4_ib_free_fast_reg_page_list
;
1660 ibdev
->ib_dev
.attach_mcast
= mlx4_ib_mcg_attach
;
1661 ibdev
->ib_dev
.detach_mcast
= mlx4_ib_mcg_detach
;
1662 ibdev
->ib_dev
.process_mad
= mlx4_ib_process_mad
;
1664 if (!mlx4_is_slave(ibdev
->dev
)) {
1665 ibdev
->ib_dev
.alloc_fmr
= mlx4_ib_fmr_alloc
;
1666 ibdev
->ib_dev
.map_phys_fmr
= mlx4_ib_map_phys_fmr
;
1667 ibdev
->ib_dev
.unmap_fmr
= mlx4_ib_unmap_fmr
;
1668 ibdev
->ib_dev
.dealloc_fmr
= mlx4_ib_fmr_dealloc
;
1671 if (dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_MEM_WINDOW
||
1672 dev
->caps
.bmme_flags
& MLX4_BMME_FLAG_TYPE_2_WIN
) {
1673 ibdev
->ib_dev
.alloc_mw
= mlx4_ib_alloc_mw
;
1674 ibdev
->ib_dev
.bind_mw
= mlx4_ib_bind_mw
;
1675 ibdev
->ib_dev
.dealloc_mw
= mlx4_ib_dealloc_mw
;
1677 ibdev
->ib_dev
.uverbs_cmd_mask
|=
1678 (1ull << IB_USER_VERBS_CMD_ALLOC_MW
) |
1679 (1ull << IB_USER_VERBS_CMD_DEALLOC_MW
);
1682 if (dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_XRC
) {
1683 ibdev
->ib_dev
.alloc_xrcd
= mlx4_ib_alloc_xrcd
;
1684 ibdev
->ib_dev
.dealloc_xrcd
= mlx4_ib_dealloc_xrcd
;
1685 ibdev
->ib_dev
.uverbs_cmd_mask
|=
1686 (1ull << IB_USER_VERBS_CMD_OPEN_XRCD
) |
1687 (1ull << IB_USER_VERBS_CMD_CLOSE_XRCD
);
1690 if (check_flow_steering_support(dev
)) {
1691 ibdev
->steering_support
= MLX4_STEERING_MODE_DEVICE_MANAGED
;
1692 ibdev
->ib_dev
.create_flow
= mlx4_ib_create_flow
;
1693 ibdev
->ib_dev
.destroy_flow
= mlx4_ib_destroy_flow
;
1695 ibdev
->ib_dev
.uverbs_ex_cmd_mask
|=
1696 (1ull << IB_USER_VERBS_EX_CMD_CREATE_FLOW
) |
1697 (1ull << IB_USER_VERBS_EX_CMD_DESTROY_FLOW
);
1700 mlx4_ib_alloc_eqs(dev
, ibdev
);
1702 spin_lock_init(&iboe
->lock
);
1704 if (init_node_data(ibdev
))
1707 for (i
= 0; i
< ibdev
->num_ports
; ++i
) {
1708 if (mlx4_ib_port_link_layer(&ibdev
->ib_dev
, i
+ 1) ==
1709 IB_LINK_LAYER_ETHERNET
) {
1710 err
= mlx4_counter_alloc(ibdev
->dev
, &ibdev
->counters
[i
]);
1712 ibdev
->counters
[i
] = -1;
1714 ibdev
->counters
[i
] = -1;
1717 spin_lock_init(&ibdev
->sm_lock
);
1718 mutex_init(&ibdev
->cap_mask_mutex
);
1720 if (ib_register_device(&ibdev
->ib_dev
, NULL
))
1723 if (mlx4_ib_mad_init(ibdev
))
1726 if (mlx4_ib_init_sriov(ibdev
))
1729 if (dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_IBOE
&& !iboe
->nb
.notifier_call
) {
1730 iboe
->nb
.notifier_call
= mlx4_ib_netdev_event
;
1731 err
= register_netdevice_notifier(&iboe
->nb
);
1736 for (j
= 0; j
< ARRAY_SIZE(mlx4_class_attributes
); ++j
) {
1737 if (device_create_file(&ibdev
->ib_dev
.dev
,
1738 mlx4_class_attributes
[j
]))
1742 ibdev
->ib_active
= true;
1744 if (mlx4_is_mfunc(ibdev
->dev
))
1747 /* create paravirt contexts for any VFs which are active */
1748 if (mlx4_is_master(ibdev
->dev
)) {
1749 for (j
= 0; j
< MLX4_MFUNC_MAX
; j
++) {
1750 if (j
== mlx4_master_func_num(ibdev
->dev
))
1752 if (mlx4_is_slave_active(ibdev
->dev
, j
))
1753 do_slave_init(ibdev
, j
, 1);
1759 if (unregister_netdevice_notifier(&ibdev
->iboe
.nb
))
1760 pr_warn("failure unregistering notifier\n");
1761 flush_workqueue(wq
);
1764 mlx4_ib_close_sriov(ibdev
);
1767 mlx4_ib_mad_cleanup(ibdev
);
1770 ib_unregister_device(&ibdev
->ib_dev
);
1774 if (ibdev
->counters
[i
- 1] != -1)
1775 mlx4_counter_free(ibdev
->dev
, ibdev
->counters
[i
- 1]);
1778 iounmap(ibdev
->uar_map
);
1781 mlx4_uar_free(dev
, &ibdev
->priv_uar
);
1784 mlx4_pd_free(dev
, ibdev
->priv_pdn
);
1787 ib_dealloc_device(&ibdev
->ib_dev
);
1792 static void mlx4_ib_remove(struct mlx4_dev
*dev
, void *ibdev_ptr
)
1794 struct mlx4_ib_dev
*ibdev
= ibdev_ptr
;
1797 mlx4_ib_close_sriov(ibdev
);
1798 mlx4_ib_mad_cleanup(ibdev
);
1799 ib_unregister_device(&ibdev
->ib_dev
);
1800 if (ibdev
->iboe
.nb
.notifier_call
) {
1801 if (unregister_netdevice_notifier(&ibdev
->iboe
.nb
))
1802 pr_warn("failure unregistering notifier\n");
1803 ibdev
->iboe
.nb
.notifier_call
= NULL
;
1805 iounmap(ibdev
->uar_map
);
1806 for (p
= 0; p
< ibdev
->num_ports
; ++p
)
1807 if (ibdev
->counters
[p
] != -1)
1808 mlx4_counter_free(ibdev
->dev
, ibdev
->counters
[p
]);
1809 mlx4_foreach_port(p
, dev
, MLX4_PORT_TYPE_IB
)
1810 mlx4_CLOSE_PORT(dev
, p
);
1812 mlx4_ib_free_eqs(dev
, ibdev
);
1814 mlx4_uar_free(dev
, &ibdev
->priv_uar
);
1815 mlx4_pd_free(dev
, ibdev
->priv_pdn
);
1816 ib_dealloc_device(&ibdev
->ib_dev
);
1819 static void do_slave_init(struct mlx4_ib_dev
*ibdev
, int slave
, int do_init
)
1821 struct mlx4_ib_demux_work
**dm
= NULL
;
1822 struct mlx4_dev
*dev
= ibdev
->dev
;
1824 unsigned long flags
;
1826 if (!mlx4_is_master(dev
))
1829 dm
= kcalloc(dev
->caps
.num_ports
, sizeof *dm
, GFP_ATOMIC
);
1831 pr_err("failed to allocate memory for tunneling qp update\n");
1835 for (i
= 0; i
< dev
->caps
.num_ports
; i
++) {
1836 dm
[i
] = kmalloc(sizeof (struct mlx4_ib_demux_work
), GFP_ATOMIC
);
1838 pr_err("failed to allocate memory for tunneling qp update work struct\n");
1839 for (i
= 0; i
< dev
->caps
.num_ports
; i
++) {
1846 /* initialize or tear down tunnel QPs for the slave */
1847 for (i
= 0; i
< dev
->caps
.num_ports
; i
++) {
1848 INIT_WORK(&dm
[i
]->work
, mlx4_ib_tunnels_update_work
);
1849 dm
[i
]->port
= i
+ 1;
1850 dm
[i
]->slave
= slave
;
1851 dm
[i
]->do_init
= do_init
;
1853 spin_lock_irqsave(&ibdev
->sriov
.going_down_lock
, flags
);
1854 if (!ibdev
->sriov
.is_going_down
)
1855 queue_work(ibdev
->sriov
.demux
[i
].ud_wq
, &dm
[i
]->work
);
1856 spin_unlock_irqrestore(&ibdev
->sriov
.going_down_lock
, flags
);
1863 static void mlx4_ib_event(struct mlx4_dev
*dev
, void *ibdev_ptr
,
1864 enum mlx4_dev_event event
, unsigned long param
)
1866 struct ib_event ibev
;
1867 struct mlx4_ib_dev
*ibdev
= to_mdev((struct ib_device
*) ibdev_ptr
);
1868 struct mlx4_eqe
*eqe
= NULL
;
1869 struct ib_event_work
*ew
;
1872 if (event
== MLX4_DEV_EVENT_PORT_MGMT_CHANGE
)
1873 eqe
= (struct mlx4_eqe
*)param
;
1878 case MLX4_DEV_EVENT_PORT_UP
:
1879 if (p
> ibdev
->num_ports
)
1881 if (mlx4_is_master(dev
) &&
1882 rdma_port_get_link_layer(&ibdev
->ib_dev
, p
) ==
1883 IB_LINK_LAYER_INFINIBAND
) {
1884 mlx4_ib_invalidate_all_guid_record(ibdev
, p
);
1886 ibev
.event
= IB_EVENT_PORT_ACTIVE
;
1889 case MLX4_DEV_EVENT_PORT_DOWN
:
1890 if (p
> ibdev
->num_ports
)
1892 ibev
.event
= IB_EVENT_PORT_ERR
;
1895 case MLX4_DEV_EVENT_CATASTROPHIC_ERROR
:
1896 ibdev
->ib_active
= false;
1897 ibev
.event
= IB_EVENT_DEVICE_FATAL
;
1900 case MLX4_DEV_EVENT_PORT_MGMT_CHANGE
:
1901 ew
= kmalloc(sizeof *ew
, GFP_ATOMIC
);
1903 pr_err("failed to allocate memory for events work\n");
1907 INIT_WORK(&ew
->work
, handle_port_mgmt_change_event
);
1908 memcpy(&ew
->ib_eqe
, eqe
, sizeof *eqe
);
1910 /* need to queue only for port owner, which uses GEN_EQE */
1911 if (mlx4_is_master(dev
))
1912 queue_work(wq
, &ew
->work
);
1914 handle_port_mgmt_change_event(&ew
->work
);
1917 case MLX4_DEV_EVENT_SLAVE_INIT
:
1918 /* here, p is the slave id */
1919 do_slave_init(ibdev
, p
, 1);
1922 case MLX4_DEV_EVENT_SLAVE_SHUTDOWN
:
1923 /* here, p is the slave id */
1924 do_slave_init(ibdev
, p
, 0);
1931 ibev
.device
= ibdev_ptr
;
1932 ibev
.element
.port_num
= (u8
) p
;
1934 ib_dispatch_event(&ibev
);
1937 static struct mlx4_interface mlx4_ib_interface
= {
1939 .remove
= mlx4_ib_remove
,
1940 .event
= mlx4_ib_event
,
1941 .protocol
= MLX4_PROT_IB_IPV6
1944 static int __init
mlx4_ib_init(void)
1948 wq
= create_singlethread_workqueue("mlx4_ib");
1952 err
= mlx4_ib_mcg_init();
1956 err
= mlx4_register_interface(&mlx4_ib_interface
);
1963 mlx4_ib_mcg_destroy();
1966 destroy_workqueue(wq
);
1970 static void __exit
mlx4_ib_cleanup(void)
1972 mlx4_unregister_interface(&mlx4_ib_interface
);
1973 mlx4_ib_mcg_destroy();
1974 destroy_workqueue(wq
);
1977 module_init(mlx4_ib_init
);
1978 module_exit(mlx4_ib_cleanup
);