1/*
2 * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33#include <linux/mlx5/driver.h>
34#include <linux/mlx5/eswitch.h>
35#include <linux/mlx5/mlx5_ifc_vdpa.h>
36#include <linux/mlx5/vport.h>
37#include "mlx5_core.h"
38#include "devlink.h"
39#include "lag/lag.h"
40
41static DEFINE_IDA(mlx5_adev_ida);
42
43static bool is_eth_rep_supported(struct mlx5_core_dev *dev)
44{
45 if (!IS_ENABLED(CONFIG_MLX5_ESWITCH))
46 return false;
47
48 if (!MLX5_ESWITCH_MANAGER(dev))
49 return false;
50
51 if (!is_mdev_switchdev_mode(dev))
52 return false;
53
54 return true;
55}
56
57bool mlx5_eth_supported(struct mlx5_core_dev *dev)
58{
59 if (!IS_ENABLED(CONFIG_MLX5_CORE_EN))
60 return false;
61
62 if (MLX5_CAP_GEN(dev, port_type) != MLX5_CAP_PORT_TYPE_ETH)
63 return false;
64
65 if (!MLX5_CAP_GEN(dev, eth_net_offloads)) {
66 mlx5_core_warn(dev, "Missing eth_net_offloads capability\n");
67 return false;
68 }
69
70 if (!MLX5_CAP_GEN(dev, nic_flow_table)) {
71 mlx5_core_warn(dev, "Missing nic_flow_table capability\n");
72 return false;
73 }
74
75 if (!MLX5_CAP_ETH(dev, csum_cap)) {
76 mlx5_core_warn(dev, "Missing csum_cap capability\n");
77 return false;
78 }
79
80 if (!MLX5_CAP_ETH(dev, max_lso_cap)) {
81 mlx5_core_warn(dev, "Missing max_lso_cap capability\n");
82 return false;
83 }
84
85 if (!MLX5_CAP_ETH(dev, vlan_cap)) {
86 mlx5_core_warn(dev, "Missing vlan_cap capability\n");
87 return false;
88 }
89
90 if (!MLX5_CAP_ETH(dev, rss_ind_tbl_cap)) {
91 mlx5_core_warn(dev, "Missing rss_ind_tbl_cap capability\n");
92 return false;
93 }
94
95 if (MLX5_CAP_FLOWTABLE(dev,
96 flow_table_properties_nic_receive.max_ft_level) < 3) {
97 mlx5_core_warn(dev, "max_ft_level < 3\n");
98 return false;
99 }
100
101 if (!MLX5_CAP_ETH(dev, self_lb_en_modifiable))
102 mlx5_core_warn(dev, "Self loop back prevention is not supported\n");
103 if (!MLX5_CAP_GEN(dev, cq_moderation))
104 mlx5_core_warn(dev, "CQ moderation is not supported\n");
105
106 return true;
107}
108
109bool mlx5_vnet_supported(struct mlx5_core_dev *dev)
110{
111 if (!IS_ENABLED(CONFIG_MLX5_VDPA_NET))
112 return false;
113
114 if (mlx5_core_is_pf(dev))
115 return false;
116
117 if (!(MLX5_CAP_GEN_64(dev, general_obj_types) &
118 MLX5_GENERAL_OBJ_TYPES_CAP_VIRTIO_NET_Q))
119 return false;
120
121 if (!(MLX5_CAP_DEV_VDPA_EMULATION(dev, event_mode) &
122 MLX5_VIRTIO_Q_EVENT_MODE_QP_MODE))
123 return false;
124
125 if (!MLX5_CAP_DEV_VDPA_EMULATION(dev, eth_frame_offload_type))
126 return false;
127
128 return true;
129}
130
131static bool is_vnet_enabled(struct mlx5_core_dev *dev)
132{
133 union devlink_param_value val;
134 int err;
135
136 err = devl_param_driverinit_value_get(devlink: priv_to_devlink(priv: dev),
137 param_id: DEVLINK_PARAM_GENERIC_ID_ENABLE_VNET,
138 val: &val);
139 return err ? false : val.vbool;
140}
141
142static bool is_ib_rep_supported(struct mlx5_core_dev *dev)
143{
144 if (!IS_ENABLED(CONFIG_MLX5_INFINIBAND))
145 return false;
146
147 if (dev->priv.flags & MLX5_PRIV_FLAGS_DISABLE_IB_ADEV)
148 return false;
149
150 if (!is_eth_rep_supported(dev))
151 return false;
152
153 if (mlx5_core_mp_enabled(dev))
154 return false;
155
156 return true;
157}
158
159static bool is_mp_supported(struct mlx5_core_dev *dev)
160{
161 if (!IS_ENABLED(CONFIG_MLX5_INFINIBAND))
162 return false;
163
164 if (dev->priv.flags & MLX5_PRIV_FLAGS_DISABLE_IB_ADEV)
165 return false;
166
167 if (is_ib_rep_supported(dev))
168 return false;
169
170 if (MLX5_CAP_GEN(dev, port_type) != MLX5_CAP_PORT_TYPE_ETH)
171 return false;
172
173 if (!mlx5_core_is_mp_slave(dev))
174 return false;
175
176 return true;
177}
178
179bool mlx5_rdma_supported(struct mlx5_core_dev *dev)
180{
181 if (!IS_ENABLED(CONFIG_MLX5_INFINIBAND))
182 return false;
183
184 if (dev->priv.flags & MLX5_PRIV_FLAGS_DISABLE_IB_ADEV)
185 return false;
186
187 if (is_ib_rep_supported(dev))
188 return false;
189
190 if (is_mp_supported(dev))
191 return false;
192
193 return true;
194}
195
196static bool is_ib_enabled(struct mlx5_core_dev *dev)
197{
198 union devlink_param_value val;
199 int err;
200
201 err = devl_param_driverinit_value_get(devlink: priv_to_devlink(priv: dev),
202 param_id: DEVLINK_PARAM_GENERIC_ID_ENABLE_RDMA,
203 val: &val);
204 return err ? false : val.vbool;
205}
206
207static bool is_dpll_supported(struct mlx5_core_dev *dev)
208{
209 if (!IS_ENABLED(CONFIG_MLX5_DPLL))
210 return false;
211
212 if (!MLX5_CAP_MCAM_REG2(dev, synce_registers)) {
213 mlx5_core_dbg(dev, "Missing SyncE capability\n");
214 return false;
215 }
216
217 return true;
218}
219
220enum {
221 MLX5_INTERFACE_PROTOCOL_ETH,
222 MLX5_INTERFACE_PROTOCOL_ETH_REP,
223
224 MLX5_INTERFACE_PROTOCOL_IB,
225 MLX5_INTERFACE_PROTOCOL_IB_REP,
226 MLX5_INTERFACE_PROTOCOL_MPIB,
227
228 MLX5_INTERFACE_PROTOCOL_VNET,
229
230 MLX5_INTERFACE_PROTOCOL_DPLL,
231 MLX5_INTERFACE_PROTOCOL_FWCTL,
232};
233
234static bool is_fwctl_supported(struct mlx5_core_dev *dev)
235{
236 /* fwctl is most useful on PFs, prevent fwctl on SFs for now */
237 return MLX5_CAP_GEN(dev, uctx_cap) && !mlx5_core_is_sf(dev);
238}
239
240static const struct mlx5_adev_device {
241 const char *suffix;
242 bool (*is_supported)(struct mlx5_core_dev *dev);
243 bool (*is_enabled)(struct mlx5_core_dev *dev);
244} mlx5_adev_devices[] = {
245 [MLX5_INTERFACE_PROTOCOL_VNET] = { .suffix = "vnet",
246 .is_supported = &mlx5_vnet_supported,
247 .is_enabled = &is_vnet_enabled },
248 [MLX5_INTERFACE_PROTOCOL_IB] = { .suffix = "rdma",
249 .is_supported = &mlx5_rdma_supported,
250 .is_enabled = &is_ib_enabled },
251 [MLX5_INTERFACE_PROTOCOL_ETH] = { .suffix = "eth",
252 .is_supported = &mlx5_eth_supported,
253 .is_enabled = &mlx5_core_is_eth_enabled },
254 [MLX5_INTERFACE_PROTOCOL_ETH_REP] = { .suffix = "eth-rep",
255 .is_supported = &is_eth_rep_supported },
256 [MLX5_INTERFACE_PROTOCOL_IB_REP] = { .suffix = "rdma-rep",
257 .is_supported = &is_ib_rep_supported },
258 [MLX5_INTERFACE_PROTOCOL_MPIB] = { .suffix = "multiport",
259 .is_supported = &is_mp_supported },
260 [MLX5_INTERFACE_PROTOCOL_DPLL] = { .suffix = "dpll",
261 .is_supported = &is_dpll_supported },
262 [MLX5_INTERFACE_PROTOCOL_FWCTL] = { .suffix = "fwctl",
263 .is_supported = &is_fwctl_supported },
264};
265
266int mlx5_adev_idx_alloc(void)
267{
268 return ida_alloc(ida: &mlx5_adev_ida, GFP_KERNEL);
269}
270
271void mlx5_adev_idx_free(int idx)
272{
273 ida_free(&mlx5_adev_ida, id: idx);
274}
275
276int mlx5_adev_init(struct mlx5_core_dev *dev)
277{
278 struct mlx5_priv *priv = &dev->priv;
279
280 priv->adev = kcalloc(ARRAY_SIZE(mlx5_adev_devices),
281 sizeof(struct mlx5_adev *), GFP_KERNEL);
282 if (!priv->adev)
283 return -ENOMEM;
284
285 return 0;
286}
287
288void mlx5_adev_cleanup(struct mlx5_core_dev *dev)
289{
290 struct mlx5_priv *priv = &dev->priv;
291
292 kfree(objp: priv->adev);
293}
294
295static void adev_release(struct device *dev)
296{
297 struct mlx5_adev *mlx5_adev =
298 container_of(dev, struct mlx5_adev, adev.dev);
299 struct mlx5_priv *priv = &mlx5_adev->mdev->priv;
300 int idx = mlx5_adev->idx;
301
302 kfree(objp: mlx5_adev);
303 priv->adev[idx] = NULL;
304}
305
306static struct mlx5_adev *add_adev(struct mlx5_core_dev *dev, int idx)
307{
308 const char *suffix = mlx5_adev_devices[idx].suffix;
309 struct auxiliary_device *adev;
310 struct mlx5_adev *madev;
311 int ret;
312
313 madev = kzalloc(sizeof(*madev), GFP_KERNEL);
314 if (!madev)
315 return ERR_PTR(error: -ENOMEM);
316
317 adev = &madev->adev;
318 adev->id = dev->priv.adev_idx;
319 adev->name = suffix;
320 adev->dev.parent = dev->device;
321 adev->dev.release = adev_release;
322 madev->mdev = dev;
323 madev->idx = idx;
324
325 ret = auxiliary_device_init(auxdev: adev);
326 if (ret) {
327 kfree(objp: madev);
328 return ERR_PTR(error: ret);
329 }
330
331 ret = auxiliary_device_add(adev);
332 if (ret) {
333 auxiliary_device_uninit(auxdev: adev);
334 return ERR_PTR(error: ret);
335 }
336 return madev;
337}
338
339static void del_adev(struct auxiliary_device *adev)
340{
341 auxiliary_device_delete(auxdev: adev);
342 auxiliary_device_uninit(auxdev: adev);
343}
344
345void mlx5_dev_set_lightweight(struct mlx5_core_dev *dev)
346{
347 mlx5_devcom_comp_lock(devcom: dev->priv.hca_devcom_comp);
348 dev->priv.flags |= MLX5_PRIV_FLAGS_DISABLE_ALL_ADEV;
349 mlx5_devcom_comp_unlock(devcom: dev->priv.hca_devcom_comp);
350}
351
352bool mlx5_dev_is_lightweight(struct mlx5_core_dev *dev)
353{
354 return dev->priv.flags & MLX5_PRIV_FLAGS_DISABLE_ALL_ADEV;
355}
356
357int mlx5_attach_device(struct mlx5_core_dev *dev)
358{
359 struct mlx5_priv *priv = &dev->priv;
360 struct auxiliary_device *adev;
361 const struct auxiliary_driver *adrv;
362 int ret = 0, i;
363
364 devl_assert_locked(devlink: priv_to_devlink(priv: dev));
365 mlx5_devcom_comp_lock(devcom: dev->priv.hca_devcom_comp);
366 priv->flags &= ~MLX5_PRIV_FLAGS_DETACH;
367 for (i = 0; i < ARRAY_SIZE(mlx5_adev_devices); i++) {
368 if (!priv->adev[i]) {
369 bool is_supported = false;
370
371 if (mlx5_adev_devices[i].is_enabled) {
372 bool enabled;
373
374 enabled = mlx5_adev_devices[i].is_enabled(dev);
375 if (!enabled)
376 continue;
377 }
378
379 if (mlx5_adev_devices[i].is_supported)
380 is_supported = mlx5_adev_devices[i].is_supported(dev);
381
382 if (!is_supported)
383 continue;
384
385 priv->adev[i] = add_adev(dev, idx: i);
386 if (IS_ERR(ptr: priv->adev[i])) {
387 ret = PTR_ERR(ptr: priv->adev[i]);
388 priv->adev[i] = NULL;
389 }
390 } else {
391 adev = &priv->adev[i]->adev;
392
393 /* Pay attention that this is not PCI driver that
394 * mlx5_core_dev is connected, but auxiliary driver.
395 */
396 if (!adev->dev.driver)
397 continue;
398 adrv = to_auxiliary_drv(drv: adev->dev.driver);
399
400 if (adrv->resume)
401 ret = adrv->resume(adev);
402 }
403 if (ret) {
404 mlx5_core_warn(dev, "Device[%d] (%s) failed to load\n",
405 i, mlx5_adev_devices[i].suffix);
406
407 break;
408 }
409 }
410 mlx5_devcom_comp_unlock(devcom: dev->priv.hca_devcom_comp);
411 return ret;
412}
413
414void mlx5_detach_device(struct mlx5_core_dev *dev, bool suspend)
415{
416 struct mlx5_priv *priv = &dev->priv;
417 struct auxiliary_device *adev;
418 const struct auxiliary_driver *adrv;
419 pm_message_t pm = {};
420 int i;
421
422 devl_assert_locked(devlink: priv_to_devlink(priv: dev));
423 mlx5_devcom_comp_lock(devcom: dev->priv.hca_devcom_comp);
424 for (i = ARRAY_SIZE(mlx5_adev_devices) - 1; i >= 0; i--) {
425 if (!priv->adev[i])
426 continue;
427
428 if (mlx5_adev_devices[i].is_enabled) {
429 bool enabled;
430
431 enabled = mlx5_adev_devices[i].is_enabled(dev);
432 if (!enabled)
433 goto skip_suspend;
434 }
435
436 adev = &priv->adev[i]->adev;
437 /* Auxiliary driver was unbind manually through sysfs */
438 if (!adev->dev.driver)
439 goto skip_suspend;
440
441 adrv = to_auxiliary_drv(drv: adev->dev.driver);
442
443 if (adrv->suspend && suspend) {
444 adrv->suspend(adev, pm);
445 continue;
446 }
447
448skip_suspend:
449 del_adev(adev: &priv->adev[i]->adev);
450 priv->adev[i] = NULL;
451 }
452 priv->flags |= MLX5_PRIV_FLAGS_DETACH;
453 mlx5_devcom_comp_unlock(devcom: dev->priv.hca_devcom_comp);
454}
455
456int mlx5_register_device(struct mlx5_core_dev *dev)
457{
458 int ret;
459
460 devl_assert_locked(devlink: priv_to_devlink(priv: dev));
461 mlx5_devcom_comp_lock(devcom: dev->priv.hca_devcom_comp);
462 dev->priv.flags &= ~MLX5_PRIV_FLAGS_DISABLE_ALL_ADEV;
463 ret = mlx5_rescan_drivers_locked(dev);
464 mlx5_devcom_comp_unlock(devcom: dev->priv.hca_devcom_comp);
465 if (ret)
466 mlx5_unregister_device(dev);
467
468 return ret;
469}
470
471void mlx5_unregister_device(struct mlx5_core_dev *dev)
472{
473 devl_assert_locked(devlink: priv_to_devlink(priv: dev));
474 mlx5_devcom_comp_lock(devcom: dev->priv.hca_devcom_comp);
475 dev->priv.flags = MLX5_PRIV_FLAGS_DISABLE_ALL_ADEV;
476 mlx5_rescan_drivers_locked(dev);
477 mlx5_devcom_comp_unlock(devcom: dev->priv.hca_devcom_comp);
478}
479
480static int add_drivers(struct mlx5_core_dev *dev)
481{
482 struct mlx5_priv *priv = &dev->priv;
483 int i, ret = 0;
484
485 for (i = 0; i < ARRAY_SIZE(mlx5_adev_devices); i++) {
486 bool is_supported = false;
487
488 if (priv->adev[i])
489 continue;
490
491 if (mlx5_adev_devices[i].is_enabled &&
492 !(mlx5_adev_devices[i].is_enabled(dev)))
493 continue;
494
495 if (mlx5_adev_devices[i].is_supported)
496 is_supported = mlx5_adev_devices[i].is_supported(dev);
497
498 if (!is_supported)
499 continue;
500
501 priv->adev[i] = add_adev(dev, idx: i);
502 if (IS_ERR(ptr: priv->adev[i])) {
503 mlx5_core_warn(dev, "Device[%d] (%s) failed to load\n",
504 i, mlx5_adev_devices[i].suffix);
505 /* We continue to rescan drivers and leave to the caller
506 * to make decision if to release everything or continue.
507 */
508 ret = PTR_ERR(ptr: priv->adev[i]);
509 priv->adev[i] = NULL;
510 }
511 }
512 return ret;
513}
514
515static void delete_drivers(struct mlx5_core_dev *dev)
516{
517 struct mlx5_priv *priv = &dev->priv;
518 bool delete_all;
519 int i;
520
521 delete_all = priv->flags & MLX5_PRIV_FLAGS_DISABLE_ALL_ADEV;
522
523 for (i = ARRAY_SIZE(mlx5_adev_devices) - 1; i >= 0; i--) {
524 bool is_supported = false;
525
526 if (!priv->adev[i])
527 continue;
528
529 if (mlx5_adev_devices[i].is_enabled) {
530 bool enabled;
531
532 enabled = mlx5_adev_devices[i].is_enabled(dev);
533 if (!enabled)
534 goto del_adev;
535 }
536
537 if (mlx5_adev_devices[i].is_supported && !delete_all)
538 is_supported = mlx5_adev_devices[i].is_supported(dev);
539
540 if (is_supported)
541 continue;
542
543del_adev:
544 del_adev(adev: &priv->adev[i]->adev);
545 priv->adev[i] = NULL;
546 }
547}
548
549/* This function is used after mlx5_core_dev is reconfigured.
550 */
551int mlx5_rescan_drivers_locked(struct mlx5_core_dev *dev)
552{
553 struct mlx5_priv *priv = &dev->priv;
554
555 if (priv->flags & MLX5_PRIV_FLAGS_DETACH)
556 return 0;
557
558 delete_drivers(dev);
559 if (priv->flags & MLX5_PRIV_FLAGS_DISABLE_ALL_ADEV)
560 return 0;
561
562 return add_drivers(dev);
563}
564
565bool mlx5_same_hw_devs(struct mlx5_core_dev *dev, struct mlx5_core_dev *peer_dev)
566{
567 u64 fsystem_guid, psystem_guid;
568
569 fsystem_guid = mlx5_query_nic_system_image_guid(mdev: dev);
570 psystem_guid = mlx5_query_nic_system_image_guid(mdev: peer_dev);
571
572 return (fsystem_guid && psystem_guid && fsystem_guid == psystem_guid);
573}
574

source code of linux/drivers/net/ethernet/mellanox/mlx5/core/dev.c