/* * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved. * * This software is available to you under a choice of one of two * licenses. You may choose to be licensed under the terms of the GNU * General Public License (GPL) Version 2, available from the file * COPYING in the main directory of this source tree, or the * OpenIB.org BSD license below: * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following * disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. #include <linux/highmem.h>#include <linux/module.h>#include <linux/init.h>#include <linux/errno.h>#include <linux/pci.h>#include <linux/dma-mapping.h>#include <linux/slab.h>#include <linux/interrupt.h>#include <linux/delay.h>#include <linux/mlx5/driver.h>#include <linux/mlx5/cq.h>#include <linux/mlx5/qp.h>#include <linux/debugfs.h>#include <linux/kmod.h>#include <linux/mlx5/mlx5_ifc.h>#include <linux/mlx5/vport.h>#include <linux/version.h>#include <net/devlink.h>#include "mlx5_core.h" #include "lib/eq.h" #include "fs_core.h" #include "lib/mpfs.h" #include "eswitch.h" #include "devlink.h" #include "fw_reset.h" #include "lib/mlx5.h" #include "lib/tout.h" #include "fpga/core.h" #include "en_accel/ipsec.h" #include "lib/clock.h" #include "lib/vxlan.h" #include "lib/geneve.h" #include "lib/devcom.h" #include "lib/pci_vsc.h" #include "diag/fw_tracer.h" #include "ecpf.h" #include "lib/hv_vhca.h" #include "diag/rsc_dump.h" #include "sf/vhca_event.h" #include "sf/dev/dev.h" #include "sf/sf.h" #include "mlx5_irq.h" #include "hwmon.h" #include "lag/lag.h" "Eli Cohen " );"Mellanox 5th generation network adapters (ConnectX series) core driver" );"Dual BSD/GPL" );unsigned int mlx5_core_debug_mask;"debug mask: 1 = dump cmd data, 2 = dump cmd exec time, 3 = both. Default=0" );static unsigned int prof_sel = MLX5_DEFAULT_PROF;"profile selector. Valid range 0 - 2" );static u32 sw_owner_id[4];#define MAX_SW_VHCA_ID (BIT(__mlx5_bit_sz(cmd_hca_cap_2, sw_vhca_id)) - 1)static DEFINE_IDA(sw_vhca_ida);enum {#define LOG_MAX_SUPPORTED_QPS 0xffstatic struct mlx5_profile profile[] = {static int wait_fw_init(struct mlx5_core_dev *dev, u32 max_wait_mili,const char *init_state)unsigned long warn = jiffies + msecs_to_jiffies(warn_time_mili);unsigned long end = jiffies + msecs_to_jiffies(max_wait_mili);do {if (!(fw_initializing >> 31))break ;if (time_after(jiffies, end)) {"Firmware over %u MS in %s state, aborting\n" ,return -ETIMEDOUT;if (test_bit(MLX5_BREAK_FW_WAIT, &dev->intf_state)) {"device is being removed, stop waiting for FW %s\n" ,return -ENODEV;if (warn_time_mili && time_after(jiffies, warn)) {"Waiting for FW %s, timeout abort in %ds (0x%x)\n" ,while (true );return 0;static void mlx5_set_driver_version(struct mlx5_core_dev *dev)int driver_ver_sz = MLX5_FLD_SZ_BYTES(set_driver_version_in,char *string;if (!MLX5_CAP_GEN(dev, driver_version))return ;"Linux,%s,%u.%u.%u" ,/*Send the command*/ static int set_dma_caps(struct pci_dev *pdev)int err;if (err) {"Warning: couldn't set 64-bit PCI DMA mask\n" );if (err) {"Can't set PCI DMA mask, aborting\n" );return err;return err;static int mlx5_pci_enable_device(struct mlx5_core_dev *dev)struct pci_dev *pdev = dev->pdev;int err = 0;if (dev->pci_status == MLX5_PCI_STATUS_DISABLED) {if (!err)return err;static void mlx5_pci_disable_device(struct mlx5_core_dev *dev)struct pci_dev *pdev = dev->pdev;if (dev->pci_status == MLX5_PCI_STATUS_ENABLED) {static int request_bar(struct pci_dev *pdev)int err = 0;if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {"Missing registers BAR, aborting\n" );return -ENODEV;if (err)"Couldn't get PCI resources, aborting\n" );return err;static void release_bar(struct pci_dev *pdev)struct mlx5_reg_host_endianness {static u16 to_fw_pkey_sz(struct mlx5_core_dev *dev, u32 size)switch (size) {case 128:return 0;case 256:return 1;case 512:return 2;case 1024:return 3;case 2048:return 4;case 4096:return 5;default :"invalid pkey table size %d\n" , size);return 0;void mlx5_core_uplink_netdev_set(struct mlx5_core_dev *dev, struct net_device *netdev)void mlx5_core_uplink_netdev_event_replay(struct mlx5_core_dev *dev)void mlx5_core_mp_event_replay(struct mlx5_core_dev *dev, u32 event, void *data)int mlx5_core_get_caps_mode(struct mlx5_core_dev *dev, enum mlx5_cap_type cap_type,enum mlx5_cap_mode cap_mode)int out_sz = MLX5_ST_SZ_BYTES(query_hca_cap_out);void *out, *hca_caps;int err;if (WARN_ON(!dev->caps.hca[cap_type]))/* this cap_type must be added to mlx5_hca_caps_alloc() */ return -EINVAL;sizeof (in));if (!out)return -ENOMEM;if (err) {"QUERY_HCA_CAP : type(%x) opmode(%x) Failed(%d)\n" ,goto query_ex;switch (cap_mode) {case HCA_CAP_OPMOD_GET_MAX:break ;case HCA_CAP_OPMOD_GET_CUR:break ;default :"Tried to query dev cap type(%x) with wrong opmode(%x)\n" ,break ;return err;int mlx5_core_get_caps(struct mlx5_core_dev *dev, enum mlx5_cap_type cap_type)int ret;if (ret)return ret;return mlx5_core_get_caps_mode(dev, cap_type, HCA_CAP_OPMOD_GET_MAX);static int set_caps(struct mlx5_core_dev *dev, void *in, int opmod)return mlx5_cmd_exec_in(dev, set_hca_cap, in);static int handle_hca_cap_atomic(struct mlx5_core_dev *dev, void *set_ctx)void *set_hca_cap;int req_endianness;int err;if (!MLX5_CAP_GEN(dev, atomic))return 0;if (err)return err;if (req_endianness != MLX5_ATOMIC_REQ_MODE_HOST_ENDIANNESS)return 0;/* Set requestor to host endianness */ return set_caps(dev, set_ctx, MLX5_SET_HCA_CAP_OP_MOD_ATOMIC);static int handle_hca_cap_odp(struct mlx5_core_dev *dev, void *set_ctx)bool do_set = false , mem_page_fault = false ;void *set_hca_cap;int err;if (!IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING) ||return 0;if (err)return err;/* For best performance, enable memory scheme ODP only when * it has page prefetch enabled. if (MLX5_CAP_ODP_MAX(dev, mem_page_fault) &&true ;true ;goto set;#define ODP_CAP_SET_MAX(dev, field) \do { \if (_res) { \true ; \while (0)if (do_set)"Using ODP %s scheme\n" ,"memory" : "transport" );return err;static int max_uc_list_get_devlink_param(struct mlx5_core_dev *dev)struct devlink *devlink = priv_to_devlink(dev);union devlink_param_value val;int err;if (!err)return val.vu32;"Failed to get param. err = %d\n" , err);return err;bool mlx5_is_roce_on(struct mlx5_core_dev *dev)struct devlink *devlink = priv_to_devlink(dev);union devlink_param_value val;int err;if (!err)return val.vbool;"Failed to get param. err = %d\n" , err);return MLX5_CAP_GEN(dev, roce);static int handle_hca_cap_2(struct mlx5_core_dev *dev, void *set_ctx)void *set_hca_cap;int err;if (!MLX5_CAP_GEN_MAX(dev, hca_cap_2))return 0;if (err)return err;if (!MLX5_CAP_GEN_2_MAX(dev, sw_vhca_id_valid) ||return 0;return set_caps(dev, set_ctx, MLX5_CAP_GENERAL_2);static int handle_hca_cap(struct mlx5_core_dev *dev, void *set_ctx)struct mlx5_profile *prof = &dev->profile;void *set_hca_cap;int max_uc_list;int err;if (err)return err;"Current Pkey table size %d Setting new size %d\n" ,/* we limit the size of the pkey table to 128 entries for now */ /* Check log_max_qp from HCA caps to set in current profile */ if (prof->log_max_qp == LOG_MAX_SUPPORTED_QPS) {else if (MLX5_CAP_GEN_MAX(dev, log_max_qp) < prof->log_max_qp) {"log_max_qp value in current profile is %d, changing it to HCA capability limit (%d)\n" ,if (prof->mask & MLX5_PROF_MASK_QP_SIZE)/* disable cmdif checksum */ /* Enable 4K UAR only when HCA supports it and page size is bigger * than 4K. if (MLX5_CAP_GEN_MAX(dev, uar_4k) && PAGE_SIZE > 4096)if (MLX5_CAP_GEN_MAX(dev, cache_line_128byte))if (MLX5_CAP_GEN_MAX(dev, dct))if (MLX5_CAP_GEN_MAX(dev, pci_sync_for_fw_update_event))if (MLX5_CAP_GEN_MAX(dev, pci_sync_for_fw_update_with_driver_unload))if (MLX5_CAP_GEN_MAX(dev, pcie_reset_using_hotreset_method))if (MLX5_CAP_GEN_MAX(dev, num_vhca_ports))if (MLX5_CAP_GEN_MAX(dev, release_all_pages))if (MLX5_CAP_GEN_MAX(dev, mkey_by_name))if (MLX5_CAP_GEN_MAX(dev, num_total_dynamic_vf_msix))if (MLX5_CAP_GEN(dev, roce_rw_supported) && MLX5_CAP_GEN_MAX(dev, roce))if (max_uc_list > 0)/* enable absolute native port num */ if (MLX5_CAP_GEN_MAX(dev, abs_native_port_num))return set_caps(dev, set_ctx, MLX5_SET_HCA_CAP_OP_MOD_GENERAL_DEVICE);/* Cached MLX5_CAP_GEN(dev, roce) can be out of sync this early in the * boot process. * In case RoCE cap is writable in FW and user/devlink requested to change the * cap, we are yet to query the final state of the above cap. * Hence, the need for this function. * * Returns * True: * 1) RoCE cap is read only in FW and already disabled * OR: * 2) RoCE cap is writable in FW and user/devlink requested it off. * * In any other case, return False. static bool is_roce_fw_disabled(struct mlx5_core_dev *dev)return (MLX5_CAP_GEN(dev, roce_rw_supported) && !mlx5_is_roce_on(dev)) ||static int handle_hca_cap_roce(struct mlx5_core_dev *dev, void *set_ctx)void *set_hca_cap;int err;if (is_roce_fw_disabled(dev))return 0;if (err)return err;if (MLX5_CAP_ROCE(dev, sw_r_roce_src_udp_port) ||return 0;if (MLX5_CAP_ROCE_MAX(dev, qp_ooo_transmit_default))return err;static int handle_hca_cap_port_selection(struct mlx5_core_dev *dev,void *set_ctx)void *set_hca_cap;int err;if (!MLX5_CAP_GEN(dev, port_selection_cap))return 0;if (err)return err;if (MLX5_CAP_PORT_SELECTION(dev, port_select_flow_table_bypass) ||return 0;return err;static int set_hca_cap(struct mlx5_core_dev *dev)int set_sz = MLX5_ST_SZ_BYTES(set_hca_cap_in);void *set_ctx;int err;if (!set_ctx)return -ENOMEM;if (err) {"handle_hca_cap failed\n" );goto out;if (err) {"handle_hca_cap_atomic failed\n" );goto out;if (err) {"handle_hca_cap_odp failed\n" );goto out;if (err) {"handle_hca_cap_roce failed\n" );goto out;if (err) {"handle_hca_cap_2 failed\n" );goto out;if (err) {"handle_hca_cap_port_selection failed\n" );goto out;return err;static int set_hca_ctrl(struct mlx5_core_dev *dev)struct mlx5_reg_host_endianness he_in;struct mlx5_reg_host_endianness he_out;int err;if (!mlx5_core_is_pf(dev))return 0;sizeof (he_in));sizeof (he_in),sizeof (he_out),return err;static int mlx5_core_set_hca_defaults(struct mlx5_core_dev *dev)int ret = 0;/* Disable local_lb by default */ if (MLX5_CAP_GEN(dev, port_type) == MLX5_CAP_PORT_TYPE_ETH)false );return ret;int mlx5_core_enable_hca(struct mlx5_core_dev *dev, u16 func_id)return mlx5_cmd_exec_in(dev, enable_hca, in);int mlx5_core_disable_hca(struct mlx5_core_dev *dev, u16 func_id)return mlx5_cmd_exec_in(dev, disable_hca, in);static int mlx5_core_set_issi(struct mlx5_core_dev *dev)int err;if (err) {if (!status || syndrome == MLX5_DRIVER_SYND) {"Failed to query ISSI err(%d) status(%d) synd(%d)\n" ,return err;"Query ISSI is not supported by FW, ISSI is 0\n" );return 0;if (sup_issi & (1 << 1)) {if (err) {"Failed to set ISSI to 1 err(%d)\n" ,return err;return 0;else if (sup_issi & (1 << 0) || !sup_issi) {return 0;return -EOPNOTSUPP;static int mlx5_pci_init(struct mlx5_core_dev *dev, struct pci_dev *pdev,const struct pci_device_id *id)int err = 0;if (err) {"Cannot enable PCI device, aborting\n" );return err;if (err) {"error requesting BARs, aborting\n" );goto err_disable;if (err) {"Failed setting DMA capabilities mask, aborting\n" );goto err_clr_master;if (pci_enable_atomic_ops_to_root(pdev, PCI_EXP_DEVCAP2_ATOMIC_COMP32) &&"Enabling pci atomics failed\n" );sizeof (*dev->iseg));if (!dev->iseg) {"Failed mapping initialization segment, aborting\n" );goto err_clr_master;return 0;return err;static void mlx5_pci_close(struct mlx5_core_dev *dev)/* health work might still be active, and it needs pci bar in * order to know the NIC state. Therefore, drain the health WQ * before removing the pci bars static void mlx5_register_hca_devcom_comp(struct mlx5_core_dev *dev)/* This component is use to sync adding core_dev to lag_dev and to sync * changes of mlx5_adev_devices between LAG layer and other layers. if (!mlx5_lag_is_supported(dev))return ;if (IS_ERR(dev->priv.hca_devcom_comp))"Failed to register devcom HCA component\n" );static void mlx5_unregister_hca_devcom_comp(struct mlx5_core_dev *dev)static int mlx5_init_once(struct mlx5_core_dev *dev)int err;if (IS_ERR(dev->priv.devc))"failed to register devcom device %ld\n" ,if (err) {"query board id failed\n" );goto err_devcom;if (err) {"failed to initialize irq table\n" );goto err_devcom;if (err) {"failed to initialize eq\n" );goto err_irq_cleanup;if (err) {"failed to initialize events\n" );goto err_eq_cleanup;if (err) {"failed to initialize fw reset events\n" );goto err_events_cleanup;if (err) {"failed to initialize hardware clock\n" );goto err_tables_cleanup;if (err) {"Failed to init rate limiting\n" );goto err_clock_cleanup;if (err) {"Failed to init l2 table %d\n" , err);goto err_rl_cleanup;if (err) {"Failed to init sriov %d\n" , err);goto err_mpfs_cleanup;if (err) {"Failed to init eswitch %d\n" , err);goto err_sriov_cleanup;if (err) {"Failed to init fpga device %d\n" , err);goto err_eswitch_cleanup;if (err) {"Failed to init vhca event notifier %d\n" , err);goto err_fpga_cleanup;if (err) {"Failed to init SF HW table %d\n" , err);goto err_sf_hw_table_cleanup;if (err) {"Failed to init SF table %d\n" , err);goto err_sf_table_cleanup;if (err) {"Failed to alloc flow steering\n" );goto err_fs;return 0;return err;static void mlx5_cleanup_once(struct mlx5_core_dev *dev)static int mlx5_function_enable(struct mlx5_core_dev *dev, bool boot, u64 timeout)int err;"firmware version: %d.%d.%d\n" , fw_rev_maj(dev),/* Only PFs hold the relevant PCIe information for this query */ if (mlx5_core_is_pf(dev))/* wait for firmware to accept initialization segments configurations "pre-initializing" );if (err)return err;if (err) {"Failed initializing command interface, aborting\n" );return err;"initializing" );if (err)goto err_cmd_cleanup;if (err) {"enable hca failed\n" );goto err_cmd_cleanup;if (err) {"failed to set issi\n" );goto stop_health_poll;if (err) {"failed to allocate boot pages\n" );goto stop_health_poll;if (err) {"failed to read dtor\n" );goto reclaim_boot_pages;return 0;return err;static void mlx5_function_disable(struct mlx5_core_dev *dev, bool boot)static int mlx5_function_open(struct mlx5_core_dev *dev)int err;if (err) {"set_hca_ctrl failed\n" );return err;if (err) {"set_hca_cap failed\n" );return err;if (err) {"failed to allocate init pages\n" );return err;if (err) {"init hca failed\n" );return err;if (err) {"query hca failed\n" );return err;return 0;static int mlx5_function_close(struct mlx5_core_dev *dev)int err;if (err) {"tear_down_hca failed, skip cleanup\n" );return err;return 0;static int mlx5_function_setup(struct mlx5_core_dev *dev, bool boot, u64 timeout)int err;if (err)return err;if (err)return err;static int mlx5_function_teardown(struct mlx5_core_dev *dev, bool boot)int err = mlx5_function_close(dev);if (!err)else return err;static int mlx5_load(struct mlx5_core_dev *dev)int err;false , false );if (err) {"Failed allocating bfreg, %d\n" , err);return err;if (err) {"Failed to alloc IRQs\n" );goto err_irq_table;if (err) {"Failed to create EQs\n" );goto err_eq_table;if (err) {"Failed to init FW tracer %d\n" , err);if (err) {"Failed to init Resource dump %d\n" , err);if (err) {"fpga device start failed %d\n" , err);goto err_fpga_start;if (err) {"Failed to init flow steering\n" );goto err_fs;if (err) {"Failed to set hca defaults\n" );goto err_set_hca;if (err) {"sf table create failed %d\n" , err);goto err_vhca;if (err) {"Failed to init embedded CPU\n" );goto err_ec;if (err) {"sriov init failed %d\n" , err);goto err_sriov;if (err)goto err_traps_reg;return 0;return err;static void mlx5_unload(struct mlx5_core_dev *dev)int mlx5_init_one_devl_locked(struct mlx5_core_dev *dev)bool light_probe = mlx5_dev_is_lightweight(dev);int err = 0;true , mlx5_tout_ms(dev, FW_PRE_INIT_TIMEOUT));if (err)goto err_function;if (err) {"sw objs init failed\n" );goto function_teardown;/* In case of light_probe, mlx5_devlink is already registered. * Hence, don't register devlink again. if (!light_probe) {if (err)goto err_devlink_params_reg;if (err)goto err_load;if (err)goto err_register;if (err)"mlx5_crdump_enable failed with error code %d\n" , err);if (err)"mlx5_hwmon_dev_register failed with error code %d\n" , err);return 0;if (!light_probe)true );return err;int mlx5_init_one(struct mlx5_core_dev *dev)struct devlink *devlink = priv_to_devlink(dev);int err;if (err)return err;void mlx5_uninit_one(struct mlx5_core_dev *dev)struct devlink *devlink = priv_to_devlink(dev);if (!test_bit(MLX5_INTERFACE_STATE_UP, &dev->intf_state)) {"%s: interface is down, NOP\n" ,goto out;true );int mlx5_load_one_devl_locked(struct mlx5_core_dev *dev, bool recovery)int err = 0;if (test_bit(MLX5_INTERFACE_STATE_UP, &dev->intf_state)) {"interface is up, NOP\n" );goto out;/* remove any previous indication of internal error */ if (recovery)else false , timeout);if (err)goto err_function;if (err)goto err_load;if (err)goto err_attach;return 0;false );return err;int mlx5_load_one(struct mlx5_core_dev *dev, bool recovery)struct devlink *devlink = priv_to_devlink(dev);int ret;return ret;void mlx5_unload_one_devl_locked(struct mlx5_core_dev *dev, bool suspend)if (!test_bit(MLX5_INTERFACE_STATE_UP, &dev->intf_state)) {"%s: interface is down, NOP\n" ,goto out;false );void mlx5_unload_one(struct mlx5_core_dev *dev, bool suspend)struct devlink *devlink = priv_to_devlink(dev);/* In case of light probe, we don't need a full query of hca_caps, but only the bellow caps. * A full query of hca_caps will be done when the device will reload. static int mlx5_query_hca_caps_light(struct mlx5_core_dev *dev)int err;if (err)return err;if (MLX5_CAP_GEN(dev, eth_net_offloads)) {if (err)return err;if (MLX5_CAP_GEN(dev, nic_flow_table) ||if (err)return err;if (MLX5_CAP_GEN_64(dev, general_obj_types) &if (err)return err;return 0;int mlx5_init_one_light(struct mlx5_core_dev *dev)struct devlink *devlink = priv_to_devlink(dev);int err;true , mlx5_tout_ms(dev, FW_PRE_INIT_TIMEOUT));if (err) {"mlx5_function_enable err=%d\n" , err);goto out;if (err) {"mlx5_query_hca_caps_light err=%d\n" , err);goto query_hca_caps_err;if (err) {"mlx5_devlink_param_reg err = %d\n" , err);goto query_hca_caps_err;return 0;true );return err;void mlx5_uninit_one_light(struct mlx5_core_dev *dev)struct devlink *devlink = priv_to_devlink(dev);if (dev->state != MLX5_DEVICE_STATE_UP)return ;true );/* xxx_light() function are used in order to configure the device without full * init (light init). e.g.: There isn't a point in reload a device to light state. * Hence, mlx5_load_one_light() isn't needed. void mlx5_unload_one_light(struct mlx5_core_dev *dev)if (dev->state != MLX5_DEVICE_STATE_UP)return ;false );static const int types[] = {static void mlx5_hca_caps_free(struct mlx5_core_dev *dev)int type;int i;for (i = 0; i < ARRAY_SIZE(types); i++) {static int mlx5_hca_caps_alloc(struct mlx5_core_dev *dev)struct mlx5_hca_cap *cap;int type;int i;for (i = 0; i < ARRAY_SIZE(types); i++) {sizeof (*cap), GFP_KERNEL);if (!cap)goto err;return 0;return -ENOMEM;static int vhca_id_show(struct seq_file *file, void *priv)struct mlx5_core_dev *dev = file->private ;"0x%x\n" , MLX5_CAP_GEN(dev, vhca_id));return 0;int mlx5_mdev_init(struct mlx5_core_dev *dev, int profile_idx)struct mlx5_priv *priv = &dev->priv;int err;sizeof (dev->profile));"vhca_id" , 0400, priv->dbg.dbg_root, dev, &vhca_id_fops);if (err) {"Failed initializing cmdif SW structs, aborting\n" );goto err_cmd_init;if (err) {"Failed initializing timeouts, aborting\n" );goto err_timeout_init;if (err)goto err_health_init;if (err)goto err_pagealloc_init;if (err)goto err_adev_init;if (err)goto err_hca_caps;/* The conjunction of sw_vhca_id with sw_owner_id will be a global * unique id per function which uses mlx5_core. * Those values are supplied to FW as part of the init HCA command to * be used by both driver and FW when it's applicable. if (dev->priv.sw_vhca_id < 0)"failed to allocate sw_vhca_id, err=%d\n" ,return 0;return err;void mlx5_mdev_uninit(struct mlx5_core_dev *dev)struct mlx5_priv *priv = &dev->priv;if (priv->sw_vhca_id > 0)static int probe_one(struct pci_dev *pdev, const struct pci_device_id *id)struct mlx5_core_dev *dev;struct devlink *devlink;int err;if (!devlink) {"devlink alloc failed\n" );return -ENOMEM;if (dev->priv.adev_idx < 0) {goto adev_init_err;if (err)goto mdev_init_err;if (err) {"mlx5_pci_init failed with error code %d\n" ,goto pci_init_err;if (err) {"mlx5_init_one failed with error code %d\n" ,goto err_init_one;return 0;return err;static void remove_one(struct pci_dev *pdev)struct mlx5_core_dev *dev = pci_get_drvdata(pdev);struct devlink *devlink = priv_to_devlink(dev);false );#define mlx5_pci_trace(dev, fmt, ...) ({ \struct mlx5_core_dev *__dev = (dev); \"%s Device state = %d health sensors: %d pci_status: %d. " fmt, \## __VA_ARGS__); \static const char *result2str(enum pci_ers_result result)return result == PCI_ERS_RESULT_NEED_RESET ? "need reset" :"disconnect" :"recovered" :"unknown" ;static pci_ers_result_t mlx5_pci_err_detected(struct pci_dev *pdev,struct mlx5_core_dev *dev = pci_get_drvdata(pdev);enum pci_ers_result res;"Enter, pci channel state = %d\n" , state);false );false );"%s Device state = %d pci_status: %d. Exit, result = %d, %s\n" ,return res;/* wait for the device to show vital signs by waiting * for the health counter to start counting. static int wait_vital(struct pci_dev *pdev)struct mlx5_core_dev *dev = pci_get_drvdata(pdev);struct mlx5_core_health *health = &dev->priv.health;const int niter = 100;int i;for (i = 0; i < niter; i++) {if (count && count != 0xffffffff) {if (last_count && last_count != count) {"wait vital counter value 0x%x after %d iterations\n" ,return 0;return -ETIMEDOUT;static pci_ers_result_t mlx5_pci_slot_reset(struct pci_dev *pdev)enum pci_ers_result res = PCI_ERS_RESULT_DISCONNECT;struct mlx5_core_dev *dev = pci_get_drvdata(pdev);int err;"%s Device state = %d pci_status: %d. Enter\n" ,if (err) {"%s: mlx5_pci_enable_device failed with error code: %d\n" ,goto out;if (err) {"%s: wait vital failed with error code: %d\n" ,goto out;"%s Device state = %d pci_status: %d. Exit, err = %d, result = %d, %s\n" ,return res;static void mlx5_pci_resume(struct pci_dev *pdev)struct mlx5_core_dev *dev = pci_get_drvdata(pdev);int err;"Enter, loading driver..\n" );false );if (!err)"Done, err = %d, device %s\n" , err,"recovered" : "Failed" );static const struct pci_error_handlers mlx5_err_handler = {static int mlx5_try_fast_unload(struct mlx5_core_dev *dev)bool fast_teardown = false , force_teardown = false ;int ret = 1;"force teardown firmware support=%d\n" , force_teardown);"fast teardown firmware support=%d\n" , fast_teardown);if (!fast_teardown && !force_teardown)return -EOPNOTSUPP;if (dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) {"Device in internal error state, giving up\n" );return -EAGAIN;/* Panic tear down fw command will stop the PCI bus communication * with the HCA, so the health poll is no longer needed. false );if (!ret)goto succeed;if (!ret)goto succeed;"Firmware couldn't do fast unload error: %d\n" , ret);return ret;true );/* Some platforms requiring freeing the IRQ's in the shutdown * flow. If they aren't freed they can't be allocated after * kexec. There is no need to cleanup the mlx5_core software * contexts. return 0;static void shutdown(struct pci_dev *pdev)struct mlx5_core_dev *dev = pci_get_drvdata(pdev);int err;"Shutdown was called\n" );if (err)false );static int mlx5_suspend(struct pci_dev *pdev, pm_message_t state)struct mlx5_core_dev *dev = pci_get_drvdata(pdev);true );return 0;static int mlx5_resume(struct pci_dev *pdev)struct mlx5_core_dev *dev = pci_get_drvdata(pdev);return mlx5_load_one(dev, false );static const struct pci_device_id mlx5_core_pci_table[] = {/* Connect-IB VF */ /* ConnectX-4 VF */ /* ConnectX-4LX VF */ /* ConnectX-5, PCIe 3.0 */ /* ConnectX-5 VF */ /* ConnectX-5 Ex */ /* ConnectX-5 Ex VF */ /* ConnectX-6 */ /* ConnectX-6 VF */ /* ConnectX-6 Dx */ /* ConnectX Family mlx5Gen Virtual Function */ /* ConnectX-6 LX */ /* ConnectX-7 */ /* ConnectX-8 */ /* ConnectX-9 */ /* ConnectX-10 */ /* BlueField integrated ConnectX-5 network controller */ /* BlueField integrated ConnectX-5 network controller VF */ /* BlueField-2 integrated ConnectX-6 Dx network controller */ /* BlueField-3 integrated ConnectX-7 network controller */ /* BlueField-4 integrated ConnectX-8 network controller */ void mlx5_disable_device(struct mlx5_core_dev *dev)false );int mlx5_recover_device(struct mlx5_core_dev *dev)if (!mlx5_core_is_sf(dev)) {if (mlx5_pci_slot_reset(dev->pdev) != PCI_ERS_RESULT_RECOVERED)return -EIO;return mlx5_load_one_devl_locked(dev, true );static struct pci_driver mlx5_core_driver = {/** * mlx5_vf_get_core_dev - Get the mlx5 core device from a given VF PCI device if * mlx5_core is its driver. * @pdev: The associated PCI device. * * Upon return the interface state lock stay held to let caller uses it safely. * Caller must ensure to use the returned mlx5 device for a narrow window * and put it back with mlx5_vf_put_core_dev() immediately once usage was over. * * Return: Pointer to the associated mlx5_core_dev or NULL. struct mlx5_core_dev *mlx5_vf_get_core_dev(struct pci_dev *pdev)struct mlx5_core_dev *mdev;if (IS_ERR(mdev))return NULL;if (!test_bit(MLX5_INTERFACE_STATE_UP, &mdev->intf_state)) {return NULL;return mdev;/** * mlx5_vf_put_core_dev - Put the mlx5 core device back. * @mdev: The mlx5 core device. * * Upon return the interface state lock is unlocked and caller should not * access the mdev any more. void mlx5_vf_put_core_dev(struct mlx5_core_dev *mdev)static void mlx5_core_verify_params(void )if (prof_sel >= ARRAY_SIZE(profile)) {"mlx5_core: WARNING: Invalid module parameter prof_sel %d, valid range 0-%zu, changing back to default(%d)\n" ,static int __init mlx5_init(void )int err;"mlx5_core name not in sync with kernel module name" );sizeof (sw_owner_id));if (err)goto err_debug;if (err)goto err_sf;if (err)goto err_pci;return 0;return err;static void __exit mlx5_cleanup(void )
Messung V0.5 C=98 H=89 G=93
¤ Dauer der Verarbeitung: 0.40 Sekunden
(vorverarbeitet)
¤ *© Formatika GbR, Deutschland
