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/slab.h>
35 #include <linux/export.h>
36 #include <linux/errno.h>
40 struct mlx4_device_context
{
41 struct list_head list
;
42 struct list_head bond_list
;
43 struct mlx4_interface
*intf
;
47 static LIST_HEAD(intf_list
);
48 static LIST_HEAD(dev_list
);
49 static DEFINE_MUTEX(intf_mutex
);
51 static void mlx4_add_device(struct mlx4_interface
*intf
, struct mlx4_priv
*priv
)
53 struct mlx4_device_context
*dev_ctx
;
55 dev_ctx
= kmalloc(sizeof *dev_ctx
, GFP_KERNEL
);
60 dev_ctx
->context
= intf
->add(&priv
->dev
);
62 if (dev_ctx
->context
) {
63 spin_lock_irq(&priv
->ctx_lock
);
64 list_add_tail(&dev_ctx
->list
, &priv
->ctx_list
);
65 spin_unlock_irq(&priv
->ctx_lock
);
70 static void mlx4_remove_device(struct mlx4_interface
*intf
, struct mlx4_priv
*priv
)
72 struct mlx4_device_context
*dev_ctx
;
74 list_for_each_entry(dev_ctx
, &priv
->ctx_list
, list
)
75 if (dev_ctx
->intf
== intf
) {
76 spin_lock_irq(&priv
->ctx_lock
);
77 list_del(&dev_ctx
->list
);
78 spin_unlock_irq(&priv
->ctx_lock
);
80 intf
->remove(&priv
->dev
, dev_ctx
->context
);
86 int mlx4_register_interface(struct mlx4_interface
*intf
)
88 struct mlx4_priv
*priv
;
90 if (!intf
->add
|| !intf
->remove
)
93 mutex_lock(&intf_mutex
);
95 list_add_tail(&intf
->list
, &intf_list
);
96 list_for_each_entry(priv
, &dev_list
, dev_list
)
97 mlx4_add_device(intf
, priv
);
99 mutex_unlock(&intf_mutex
);
103 EXPORT_SYMBOL_GPL(mlx4_register_interface
);
105 void mlx4_unregister_interface(struct mlx4_interface
*intf
)
107 struct mlx4_priv
*priv
;
109 mutex_lock(&intf_mutex
);
111 list_for_each_entry(priv
, &dev_list
, dev_list
)
112 mlx4_remove_device(intf
, priv
);
114 list_del(&intf
->list
);
116 mutex_unlock(&intf_mutex
);
118 EXPORT_SYMBOL_GPL(mlx4_unregister_interface
);
120 int mlx4_do_bond(struct mlx4_dev
*dev
, bool enable
)
122 struct mlx4_priv
*priv
= mlx4_priv(dev
);
123 struct mlx4_device_context
*dev_ctx
= NULL
, *temp_dev_ctx
;
126 LIST_HEAD(bond_list
);
128 if (!(dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_PORT_REMAP
))
131 ret
= mlx4_disable_rx_port_check(dev
, enable
);
133 mlx4_err(dev
, "Fail to %s rx port check\n",
134 enable
? "enable" : "disable");
138 dev
->flags
|= MLX4_FLAG_BONDED
;
140 ret
= mlx4_virt2phy_port_map(dev
, 1, 2);
142 mlx4_err(dev
, "Fail to reset port map\n");
145 dev
->flags
&= ~MLX4_FLAG_BONDED
;
148 spin_lock_irqsave(&priv
->ctx_lock
, flags
);
149 list_for_each_entry_safe(dev_ctx
, temp_dev_ctx
, &priv
->ctx_list
, list
) {
150 if (dev_ctx
->intf
->flags
& MLX4_INTFF_BONDING
) {
151 list_add_tail(&dev_ctx
->bond_list
, &bond_list
);
152 list_del(&dev_ctx
->list
);
155 spin_unlock_irqrestore(&priv
->ctx_lock
, flags
);
157 list_for_each_entry(dev_ctx
, &bond_list
, bond_list
) {
158 dev_ctx
->intf
->remove(dev
, dev_ctx
->context
);
159 dev_ctx
->context
= dev_ctx
->intf
->add(dev
);
161 spin_lock_irqsave(&priv
->ctx_lock
, flags
);
162 list_add_tail(&dev_ctx
->list
, &priv
->ctx_list
);
163 spin_unlock_irqrestore(&priv
->ctx_lock
, flags
);
165 mlx4_dbg(dev
, "Inrerface for protocol %d restarted with when bonded mode is %s\n",
166 dev_ctx
->intf
->protocol
, enable
?
167 "enabled" : "disabled");
172 void mlx4_dispatch_event(struct mlx4_dev
*dev
, enum mlx4_dev_event type
,
175 struct mlx4_priv
*priv
= mlx4_priv(dev
);
176 struct mlx4_device_context
*dev_ctx
;
179 spin_lock_irqsave(&priv
->ctx_lock
, flags
);
181 list_for_each_entry(dev_ctx
, &priv
->ctx_list
, list
)
182 if (dev_ctx
->intf
->event
)
183 dev_ctx
->intf
->event(dev
, dev_ctx
->context
, type
, param
);
185 spin_unlock_irqrestore(&priv
->ctx_lock
, flags
);
188 int mlx4_register_device(struct mlx4_dev
*dev
)
190 struct mlx4_priv
*priv
= mlx4_priv(dev
);
191 struct mlx4_interface
*intf
;
193 mutex_lock(&intf_mutex
);
195 dev
->persist
->interface_state
|= MLX4_INTERFACE_STATE_UP
;
196 list_add_tail(&priv
->dev_list
, &dev_list
);
197 list_for_each_entry(intf
, &intf_list
, list
)
198 mlx4_add_device(intf
, priv
);
200 mutex_unlock(&intf_mutex
);
201 mlx4_start_catas_poll(dev
);
206 void mlx4_unregister_device(struct mlx4_dev
*dev
)
208 struct mlx4_priv
*priv
= mlx4_priv(dev
);
209 struct mlx4_interface
*intf
;
211 mlx4_stop_catas_poll(dev
);
212 mutex_lock(&intf_mutex
);
214 list_for_each_entry(intf
, &intf_list
, list
)
215 mlx4_remove_device(intf
, priv
);
217 list_del(&priv
->dev_list
);
218 dev
->persist
->interface_state
&= ~MLX4_INTERFACE_STATE_UP
;
220 mutex_unlock(&intf_mutex
);
223 void *mlx4_get_protocol_dev(struct mlx4_dev
*dev
, enum mlx4_protocol proto
, int port
)
225 struct mlx4_priv
*priv
= mlx4_priv(dev
);
226 struct mlx4_device_context
*dev_ctx
;
230 spin_lock_irqsave(&priv
->ctx_lock
, flags
);
232 list_for_each_entry(dev_ctx
, &priv
->ctx_list
, list
)
233 if (dev_ctx
->intf
->protocol
== proto
&& dev_ctx
->intf
->get_dev
) {
234 result
= dev_ctx
->intf
->get_dev(dev
, dev_ctx
->context
, port
);
238 spin_unlock_irqrestore(&priv
->ctx_lock
, flags
);
242 EXPORT_SYMBOL_GPL(mlx4_get_protocol_dev
);