// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/device.h> #include <linux/export.h> #include <linux/err.h> #include <linux/if_link.h> #include <linux/netdevice.h> #include <linux/completion.h> #include <linux/skbuff.h> #include <linux/etherdevice.h> #include <linux/types.h> #include <linux/string.h> #include <linux/gfp.h> #include <linux/random.h> #include <linux/jiffies.h> #include <linux/mutex.h> #include <linux/rcupdate.h> #include <linux/slab.h> #include <linux/workqueue.h> #include <linux/firmware.h> #include <asm/byteorder.h> #include <net/devlink.h> #include <trace/events/devlink.h> #include "core.h" #include "core_env.h" #include "item.h" #include "cmd.h" #include "port.h" #include "trap.h" #include "emad.h" #include "reg.h" #include "resources.h" #include "../mlxfw/mlxfw.h" static LIST_HEAD(mlxsw_core_driver_list); static DEFINE_SPINLOCK(mlxsw_core_driver_list_lock); static const char mlxsw_core_driver_name[] = …; static struct workqueue_struct *mlxsw_wq; static struct workqueue_struct *mlxsw_owq; struct mlxsw_core_port { … }; void *mlxsw_core_port_driver_priv(struct mlxsw_core_port *mlxsw_core_port) { … } EXPORT_SYMBOL(…); static bool mlxsw_core_port_check(struct mlxsw_core_port *mlxsw_core_port) { … } struct mlxsw_core { … }; struct mlxsw_linecards *mlxsw_core_linecards(struct mlxsw_core *mlxsw_core) { … } void mlxsw_core_linecards_set(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards *linecards) { … } #define MLXSW_PORT_MAX_PORTS_DEFAULT … static u64 mlxsw_ports_occ_get(void *priv) { … } static int mlxsw_core_resources_ports_register(struct mlxsw_core *mlxsw_core) { … } static int mlxsw_ports_init(struct mlxsw_core *mlxsw_core, bool reload) { … } static void mlxsw_ports_fini(struct mlxsw_core *mlxsw_core, bool reload) { … } unsigned int mlxsw_core_max_ports(const struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); int mlxsw_core_max_lag(struct mlxsw_core *mlxsw_core, u16 *p_max_lag) { … } EXPORT_SYMBOL(…); enum mlxsw_cmd_mbox_config_profile_lag_mode mlxsw_core_lag_mode(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); enum mlxsw_cmd_mbox_config_profile_flood_mode mlxsw_core_flood_mode(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); void *mlxsw_core_driver_priv(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); bool mlxsw_core_fw_rev_minor_subminor_validate(const struct mlxsw_fw_rev *rev, const struct mlxsw_fw_rev *req_rev) { … } EXPORT_SYMBOL(…); struct mlxsw_rx_listener_item { … }; struct mlxsw_event_listener_item { … }; static const u8 mlxsw_core_trap_groups[] = …; static int mlxsw_core_trap_groups_set(struct mlxsw_core *mlxsw_core) { … } /****************** * EMAD processing ******************/ /* emad_eth_hdr_dmac * Destination MAC in EMAD's Ethernet header. * Must be set to 01:02:c9:00:00:01 */ MLXSW_ITEM_BUF(emad, eth_hdr, dmac, 0x00, 6); /* emad_eth_hdr_smac * Source MAC in EMAD's Ethernet header. * Must be set to 00:02:c9:01:02:03 */ MLXSW_ITEM_BUF(emad, eth_hdr, smac, 0x06, 6); /* emad_eth_hdr_ethertype * Ethertype in EMAD's Ethernet header. * Must be set to 0x8932 */ MLXSW_ITEM32(emad, eth_hdr, ethertype, 0x0C, 16, 16); /* emad_eth_hdr_mlx_proto * Mellanox protocol. * Must be set to 0x0. */ MLXSW_ITEM32(emad, eth_hdr, mlx_proto, 0x0C, 8, 8); /* emad_eth_hdr_ver * Mellanox protocol version. * Must be set to 0x0. */ MLXSW_ITEM32(emad, eth_hdr, ver, 0x0C, 4, 4); /* emad_op_tlv_type * Type of the TLV. * Must be set to 0x1 (operation TLV). */ MLXSW_ITEM32(emad, op_tlv, type, 0x00, 27, 5); /* emad_op_tlv_len * Length of the operation TLV in u32. * Must be set to 0x4. */ MLXSW_ITEM32(emad, op_tlv, len, 0x00, 16, 11); /* emad_op_tlv_dr * Direct route bit. Setting to 1 indicates the EMAD is a direct route * EMAD. DR TLV must follow. * * Note: Currently not supported and must not be set. */ MLXSW_ITEM32(emad, op_tlv, dr, 0x00, 15, 1); /* emad_op_tlv_status * Returned status in case of EMAD response. Must be set to 0 in case * of EMAD request. * 0x0 - success * 0x1 - device is busy. Requester should retry * 0x2 - Mellanox protocol version not supported * 0x3 - unknown TLV * 0x4 - register not supported * 0x5 - operation class not supported * 0x6 - EMAD method not supported * 0x7 - bad parameter (e.g. port out of range) * 0x8 - resource not available * 0x9 - message receipt acknowledgment. Requester should retry * 0x70 - internal error */ MLXSW_ITEM32(emad, op_tlv, status, 0x00, 8, 7); /* emad_op_tlv_register_id * Register ID of register within register TLV. */ MLXSW_ITEM32(emad, op_tlv, register_id, 0x04, 16, 16); /* emad_op_tlv_r * Response bit. Setting to 1 indicates Response, otherwise request. */ MLXSW_ITEM32(emad, op_tlv, r, 0x04, 15, 1); /* emad_op_tlv_method * EMAD method type. * 0x1 - query * 0x2 - write * 0x3 - send (currently not supported) * 0x4 - event */ MLXSW_ITEM32(emad, op_tlv, method, 0x04, 8, 7); /* emad_op_tlv_class * EMAD operation class. Must be set to 0x1 (REG_ACCESS). */ MLXSW_ITEM32(emad, op_tlv, class, 0x04, 0, 8); /* emad_op_tlv_tid * EMAD transaction ID. Used for pairing request and response EMADs. */ MLXSW_ITEM64(emad, op_tlv, tid, 0x08, 0, 64); /* emad_string_tlv_type * Type of the TLV. * Must be set to 0x2 (string TLV). */ MLXSW_ITEM32(emad, string_tlv, type, 0x00, 27, 5); /* emad_string_tlv_len * Length of the string TLV in u32. */ MLXSW_ITEM32(emad, string_tlv, len, 0x00, 16, 11); #define MLXSW_EMAD_STRING_TLV_STRING_LEN … /* emad_string_tlv_string * String provided by the device's firmware in case of erroneous register access */ MLXSW_ITEM_BUF(emad, string_tlv, string, 0x04, MLXSW_EMAD_STRING_TLV_STRING_LEN); /* emad_latency_tlv_type * Type of the TLV. * Must be set to 0x4 (latency TLV). */ MLXSW_ITEM32(emad, latency_tlv, type, 0x00, 27, 5); /* emad_latency_tlv_len * Length of the latency TLV in u32. */ MLXSW_ITEM32(emad, latency_tlv, len, 0x00, 16, 11); /* emad_latency_tlv_latency_time * EMAD latency time in units of uSec. */ MLXSW_ITEM32(emad, latency_tlv, latency_time, 0x04, 0, 32); /* emad_reg_tlv_type * Type of the TLV. * Must be set to 0x3 (register TLV). */ MLXSW_ITEM32(emad, reg_tlv, type, 0x00, 27, 5); /* emad_reg_tlv_len * Length of the operation TLV in u32. */ MLXSW_ITEM32(emad, reg_tlv, len, 0x00, 16, 11); /* emad_end_tlv_type * Type of the TLV. * Must be set to 0x0 (end TLV). */ MLXSW_ITEM32(emad, end_tlv, type, 0x00, 27, 5); /* emad_end_tlv_len * Length of the end TLV in u32. * Must be set to 1. */ MLXSW_ITEM32(emad, end_tlv, len, 0x00, 16, 11); enum mlxsw_core_reg_access_type { … }; static inline const char * mlxsw_core_reg_access_type_str(enum mlxsw_core_reg_access_type type) { … } static void mlxsw_emad_pack_end_tlv(char *end_tlv) { … } static void mlxsw_emad_pack_reg_tlv(char *reg_tlv, const struct mlxsw_reg_info *reg, char *payload) { … } static void mlxsw_emad_pack_string_tlv(char *string_tlv) { … } static void mlxsw_emad_pack_op_tlv(char *op_tlv, const struct mlxsw_reg_info *reg, enum mlxsw_core_reg_access_type type, u64 tid) { … } static void mlxsw_emad_pack_latency_tlv(char *latency_tlv) { … } static int mlxsw_emad_construct_eth_hdr(struct sk_buff *skb) { … } static void mlxsw_emad_construct(const struct mlxsw_core *mlxsw_core, struct sk_buff *skb, const struct mlxsw_reg_info *reg, char *payload, enum mlxsw_core_reg_access_type type, u64 tid) { … } struct mlxsw_emad_tlv_offsets { … }; static bool mlxsw_emad_tlv_is_string_tlv(const char *tlv) { … } static bool mlxsw_emad_tlv_is_latency_tlv(const char *tlv) { … } static void mlxsw_emad_tlv_parse(struct sk_buff *skb) { … } static char *mlxsw_emad_op_tlv(const struct sk_buff *skb) { … } static char *mlxsw_emad_string_tlv(const struct sk_buff *skb) { … } static char *mlxsw_emad_reg_tlv(const struct sk_buff *skb) { … } static char *mlxsw_emad_reg_payload(const char *reg_tlv) { … } static char *mlxsw_emad_reg_payload_cmd(const char *mbox) { … } static u64 mlxsw_emad_get_tid(const struct sk_buff *skb) { … } static bool mlxsw_emad_is_resp(const struct sk_buff *skb) { … } static int mlxsw_emad_process_status(char *op_tlv, enum mlxsw_emad_op_tlv_status *p_status) { … } static int mlxsw_emad_process_status_skb(struct sk_buff *skb, enum mlxsw_emad_op_tlv_status *p_status) { … } struct mlxsw_reg_trans { … }; static void mlxsw_emad_process_string_tlv(const struct sk_buff *skb, struct mlxsw_reg_trans *trans) { … } #define MLXSW_EMAD_TIMEOUT_DURING_FW_FLASH_MS … #define MLXSW_EMAD_TIMEOUT_MS … static void mlxsw_emad_trans_timeout_schedule(struct mlxsw_reg_trans *trans) { … } static int mlxsw_emad_transmit(struct mlxsw_core *mlxsw_core, struct mlxsw_reg_trans *trans) { … } static void mlxsw_emad_trans_finish(struct mlxsw_reg_trans *trans, int err) { … } static void mlxsw_emad_transmit_retry(struct mlxsw_core *mlxsw_core, struct mlxsw_reg_trans *trans) { … } static void mlxsw_emad_trans_timeout_work(struct work_struct *work) { … } static void mlxsw_emad_process_response(struct mlxsw_core *mlxsw_core, struct mlxsw_reg_trans *trans, struct sk_buff *skb) { … } /* called with rcu read lock held */ static void mlxsw_emad_rx_listener_func(struct sk_buff *skb, u16 local_port, void *priv) { … } static const struct mlxsw_listener mlxsw_emad_rx_listener = …; static int mlxsw_emad_tlv_enable(struct mlxsw_core *mlxsw_core) { … } static void mlxsw_emad_tlv_disable(struct mlxsw_core *mlxsw_core) { … } static int mlxsw_emad_init(struct mlxsw_core *mlxsw_core) { … } static void mlxsw_emad_fini(struct mlxsw_core *mlxsw_core) { … } static struct sk_buff *mlxsw_emad_alloc(const struct mlxsw_core *mlxsw_core, u16 reg_len) { … } static int mlxsw_emad_reg_access(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload, enum mlxsw_core_reg_access_type type, struct mlxsw_reg_trans *trans, struct list_head *bulk_list, mlxsw_reg_trans_cb_t *cb, unsigned long cb_priv, u64 tid) { … } /***************** * Core functions *****************/ int mlxsw_core_driver_register(struct mlxsw_driver *mlxsw_driver) { … } EXPORT_SYMBOL(…); void mlxsw_core_driver_unregister(struct mlxsw_driver *mlxsw_driver) { … } EXPORT_SYMBOL(…); static struct mlxsw_driver *__driver_find(const char *kind) { … } static struct mlxsw_driver *mlxsw_core_driver_get(const char *kind) { … } int mlxsw_core_fw_flash(struct mlxsw_core *mlxsw_core, struct mlxfw_dev *mlxfw_dev, const struct firmware *firmware, struct netlink_ext_ack *extack) { … } struct mlxsw_core_fw_info { … }; static int mlxsw_core_fw_component_query(struct mlxfw_dev *mlxfw_dev, u16 component_index, u32 *p_max_size, u8 *p_align_bits, u16 *p_max_write_size) { … } static int mlxsw_core_fw_fsm_lock(struct mlxfw_dev *mlxfw_dev, u32 *fwhandle) { … } static int mlxsw_core_fw_fsm_component_update(struct mlxfw_dev *mlxfw_dev, u32 fwhandle, u16 component_index, u32 component_size) { … } static int mlxsw_core_fw_fsm_block_download(struct mlxfw_dev *mlxfw_dev, u32 fwhandle, u8 *data, u16 size, u32 offset) { … } static int mlxsw_core_fw_fsm_component_verify(struct mlxfw_dev *mlxfw_dev, u32 fwhandle, u16 component_index) { … } static int mlxsw_core_fw_fsm_activate(struct mlxfw_dev *mlxfw_dev, u32 fwhandle) { … } static int mlxsw_core_fw_fsm_query_state(struct mlxfw_dev *mlxfw_dev, u32 fwhandle, enum mlxfw_fsm_state *fsm_state, enum mlxfw_fsm_state_err *fsm_state_err) { … } static void mlxsw_core_fw_fsm_cancel(struct mlxfw_dev *mlxfw_dev, u32 fwhandle) { … } static void mlxsw_core_fw_fsm_release(struct mlxfw_dev *mlxfw_dev, u32 fwhandle) { … } static const struct mlxfw_dev_ops mlxsw_core_fw_mlxsw_dev_ops = …; static int mlxsw_core_dev_fw_flash(struct mlxsw_core *mlxsw_core, const struct firmware *firmware, struct netlink_ext_ack *extack) { … } static int mlxsw_core_fw_rev_validate(struct mlxsw_core *mlxsw_core, const struct mlxsw_bus_info *mlxsw_bus_info, const struct mlxsw_fw_rev *req_rev, const char *filename) { … } static int mlxsw_core_fw_flash_update(struct mlxsw_core *mlxsw_core, struct devlink_flash_update_params *params, struct netlink_ext_ack *extack) { … } static int mlxsw_core_devlink_param_fw_load_policy_validate(struct devlink *devlink, u32 id, union devlink_param_value val, struct netlink_ext_ack *extack) { … } static const struct devlink_param mlxsw_core_fw_devlink_params[] = …; static int mlxsw_core_fw_params_register(struct mlxsw_core *mlxsw_core) { … } static void mlxsw_core_fw_params_unregister(struct mlxsw_core *mlxsw_core) { … } static void *__dl_port(struct devlink_port *devlink_port) { … } static int mlxsw_devlink_port_split(struct devlink *devlink, struct devlink_port *port, unsigned int count, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_port_unsplit(struct devlink *devlink, struct devlink_port *port, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_sb_pool_get(struct devlink *devlink, unsigned int sb_index, u16 pool_index, struct devlink_sb_pool_info *pool_info) { … } static int mlxsw_devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index, u16 pool_index, u32 size, enum devlink_sb_threshold_type threshold_type, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_sb_port_pool_get(struct devlink_port *devlink_port, unsigned int sb_index, u16 pool_index, u32 *p_threshold) { … } static int mlxsw_devlink_sb_port_pool_set(struct devlink_port *devlink_port, unsigned int sb_index, u16 pool_index, u32 threshold, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_sb_tc_pool_bind_get(struct devlink_port *devlink_port, unsigned int sb_index, u16 tc_index, enum devlink_sb_pool_type pool_type, u16 *p_pool_index, u32 *p_threshold) { … } static int mlxsw_devlink_sb_tc_pool_bind_set(struct devlink_port *devlink_port, unsigned int sb_index, u16 tc_index, enum devlink_sb_pool_type pool_type, u16 pool_index, u32 threshold, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_sb_occ_snapshot(struct devlink *devlink, unsigned int sb_index) { … } static int mlxsw_devlink_sb_occ_max_clear(struct devlink *devlink, unsigned int sb_index) { … } static int mlxsw_devlink_sb_occ_port_pool_get(struct devlink_port *devlink_port, unsigned int sb_index, u16 pool_index, u32 *p_cur, u32 *p_max) { … } static int mlxsw_devlink_sb_occ_tc_port_bind_get(struct devlink_port *devlink_port, unsigned int sb_index, u16 tc_index, enum devlink_sb_pool_type pool_type, u32 *p_cur, u32 *p_max) { … } static int mlxsw_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_core_bus_device_reload_down(struct devlink *devlink, bool netns_change, enum devlink_reload_action action, enum devlink_reload_limit limit, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_core_bus_device_reload_up(struct devlink *devlink, enum devlink_reload_action action, enum devlink_reload_limit limit, u32 *actions_performed, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_flash_update(struct devlink *devlink, struct devlink_flash_update_params *params, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_trap_init(struct devlink *devlink, const struct devlink_trap *trap, void *trap_ctx) { … } static void mlxsw_devlink_trap_fini(struct devlink *devlink, const struct devlink_trap *trap, void *trap_ctx) { … } static int mlxsw_devlink_trap_action_set(struct devlink *devlink, const struct devlink_trap *trap, enum devlink_trap_action action, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_trap_group_init(struct devlink *devlink, const struct devlink_trap_group *group) { … } static int mlxsw_devlink_trap_group_set(struct devlink *devlink, const struct devlink_trap_group *group, const struct devlink_trap_policer *policer, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_trap_policer_init(struct devlink *devlink, const struct devlink_trap_policer *policer) { … } static void mlxsw_devlink_trap_policer_fini(struct devlink *devlink, const struct devlink_trap_policer *policer) { … } static int mlxsw_devlink_trap_policer_set(struct devlink *devlink, const struct devlink_trap_policer *policer, u64 rate, u64 burst, struct netlink_ext_ack *extack) { … } static int mlxsw_devlink_trap_policer_counter_get(struct devlink *devlink, const struct devlink_trap_policer *policer, u64 *p_drops) { … } static const struct devlink_ops mlxsw_devlink_ops = …; static int mlxsw_core_params_register(struct mlxsw_core *mlxsw_core) { … } static void mlxsw_core_params_unregister(struct mlxsw_core *mlxsw_core) { … } struct mlxsw_core_health_event { … }; static void mlxsw_core_health_event_work(struct work_struct *work) { … } static void mlxsw_core_health_listener_func(const struct mlxsw_reg_info *reg, char *mfde_pl, void *priv) { … } static const struct mlxsw_listener mlxsw_core_health_listener = …; static void mlxsw_core_health_fw_fatal_dump_fatal_cause(const char *mfde_pl, struct devlink_fmsg *fmsg) { … } static void mlxsw_core_health_fw_fatal_dump_fw_assert(const char *mfde_pl, struct devlink_fmsg *fmsg) { … } static void mlxsw_core_health_fw_fatal_dump_kvd_im_stop(const char *mfde_pl, struct devlink_fmsg *fmsg) { … } static void mlxsw_core_health_fw_fatal_dump_crspace_to(const char *mfde_pl, struct devlink_fmsg *fmsg) { … } static int mlxsw_core_health_fw_fatal_dump(struct devlink_health_reporter *reporter, struct devlink_fmsg *fmsg, void *priv_ctx, struct netlink_ext_ack *extack) { … } static int mlxsw_core_health_fw_fatal_test(struct devlink_health_reporter *reporter, struct netlink_ext_ack *extack) { … } static const struct devlink_health_reporter_ops mlxsw_core_health_fw_fatal_ops = …; static int mlxsw_core_health_fw_fatal_config(struct mlxsw_core *mlxsw_core, bool enable) { … } static int mlxsw_core_health_init(struct mlxsw_core *mlxsw_core) { … } static void mlxsw_core_health_fini(struct mlxsw_core *mlxsw_core) { … } static void mlxsw_core_irq_event_handler_init(struct mlxsw_core *mlxsw_core) { … } static void mlxsw_core_irq_event_handler_fini(struct mlxsw_core *mlxsw_core) { … } static int __mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info, const struct mlxsw_bus *mlxsw_bus, void *bus_priv, bool reload, struct devlink *devlink, struct netlink_ext_ack *extack) { … } int mlxsw_core_bus_device_register(const struct mlxsw_bus_info *mlxsw_bus_info, const struct mlxsw_bus *mlxsw_bus, void *bus_priv, bool reload, struct devlink *devlink, struct netlink_ext_ack *extack) { … } EXPORT_SYMBOL(…); void mlxsw_core_bus_device_unregister(struct mlxsw_core *mlxsw_core, bool reload) { … } EXPORT_SYMBOL(…); bool mlxsw_core_skb_transmit_busy(struct mlxsw_core *mlxsw_core, const struct mlxsw_tx_info *tx_info) { … } EXPORT_SYMBOL(…); int mlxsw_core_skb_transmit(struct mlxsw_core *mlxsw_core, struct sk_buff *skb, const struct mlxsw_tx_info *tx_info) { … } EXPORT_SYMBOL(…); void mlxsw_core_ptp_transmitted(struct mlxsw_core *mlxsw_core, struct sk_buff *skb, u16 local_port) { … } EXPORT_SYMBOL(…); static bool __is_rx_listener_equal(const struct mlxsw_rx_listener *rxl_a, const struct mlxsw_rx_listener *rxl_b) { … } static struct mlxsw_rx_listener_item * __find_rx_listener_item(struct mlxsw_core *mlxsw_core, const struct mlxsw_rx_listener *rxl) { … } int mlxsw_core_rx_listener_register(struct mlxsw_core *mlxsw_core, const struct mlxsw_rx_listener *rxl, void *priv, bool enabled) { … } EXPORT_SYMBOL(…); void mlxsw_core_rx_listener_unregister(struct mlxsw_core *mlxsw_core, const struct mlxsw_rx_listener *rxl) { … } EXPORT_SYMBOL(…); static void mlxsw_core_rx_listener_state_set(struct mlxsw_core *mlxsw_core, const struct mlxsw_rx_listener *rxl, bool enabled) { … } static void mlxsw_core_event_listener_func(struct sk_buff *skb, u16 local_port, void *priv) { … } static bool __is_event_listener_equal(const struct mlxsw_event_listener *el_a, const struct mlxsw_event_listener *el_b) { … } static struct mlxsw_event_listener_item * __find_event_listener_item(struct mlxsw_core *mlxsw_core, const struct mlxsw_event_listener *el) { … } int mlxsw_core_event_listener_register(struct mlxsw_core *mlxsw_core, const struct mlxsw_event_listener *el, void *priv) { … } EXPORT_SYMBOL(…); void mlxsw_core_event_listener_unregister(struct mlxsw_core *mlxsw_core, const struct mlxsw_event_listener *el) { … } EXPORT_SYMBOL(…); static int mlxsw_core_listener_register(struct mlxsw_core *mlxsw_core, const struct mlxsw_listener *listener, void *priv, bool enabled) { … } static void mlxsw_core_listener_unregister(struct mlxsw_core *mlxsw_core, const struct mlxsw_listener *listener, void *priv) { … } int mlxsw_core_trap_register(struct mlxsw_core *mlxsw_core, const struct mlxsw_listener *listener, void *priv) { … } EXPORT_SYMBOL(…); void mlxsw_core_trap_unregister(struct mlxsw_core *mlxsw_core, const struct mlxsw_listener *listener, void *priv) { … } EXPORT_SYMBOL(…); int mlxsw_core_traps_register(struct mlxsw_core *mlxsw_core, const struct mlxsw_listener *listeners, size_t listeners_count, void *priv) { … } EXPORT_SYMBOL(…); void mlxsw_core_traps_unregister(struct mlxsw_core *mlxsw_core, const struct mlxsw_listener *listeners, size_t listeners_count, void *priv) { … } EXPORT_SYMBOL(…); int mlxsw_core_trap_state_set(struct mlxsw_core *mlxsw_core, const struct mlxsw_listener *listener, bool enabled) { … } EXPORT_SYMBOL(…); static u64 mlxsw_core_tid_get(struct mlxsw_core *mlxsw_core) { … } static int mlxsw_core_reg_access_emad(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload, enum mlxsw_core_reg_access_type type, struct list_head *bulk_list, mlxsw_reg_trans_cb_t *cb, unsigned long cb_priv) { … } int mlxsw_reg_trans_query(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload, struct list_head *bulk_list, mlxsw_reg_trans_cb_t *cb, unsigned long cb_priv) { … } EXPORT_SYMBOL(…); int mlxsw_reg_trans_write(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload, struct list_head *bulk_list, mlxsw_reg_trans_cb_t *cb, unsigned long cb_priv) { … } EXPORT_SYMBOL(…); #define MLXSW_REG_TRANS_ERR_STRING_SIZE … static int mlxsw_reg_trans_wait(struct mlxsw_reg_trans *trans) { … } int mlxsw_reg_trans_bulk_wait(struct list_head *bulk_list) { … } EXPORT_SYMBOL(…); struct mlxsw_core_irq_event_handler_item { … }; int mlxsw_core_irq_event_handler_register(struct mlxsw_core *mlxsw_core, mlxsw_irq_event_cb_t cb) { … } EXPORT_SYMBOL(…); void mlxsw_core_irq_event_handler_unregister(struct mlxsw_core *mlxsw_core, mlxsw_irq_event_cb_t cb) { … } EXPORT_SYMBOL(…); void mlxsw_core_irq_event_handlers_call(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); static int mlxsw_core_reg_access_cmd(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload, enum mlxsw_core_reg_access_type type) { … } static void mlxsw_core_reg_access_cb(struct mlxsw_core *mlxsw_core, char *payload, size_t payload_len, unsigned long cb_priv) { … } static int mlxsw_core_reg_access(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload, enum mlxsw_core_reg_access_type type) { … } int mlxsw_reg_query(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload) { … } EXPORT_SYMBOL(…); int mlxsw_reg_write(struct mlxsw_core *mlxsw_core, const struct mlxsw_reg_info *reg, char *payload) { … } EXPORT_SYMBOL(…); void mlxsw_core_skb_receive(struct mlxsw_core *mlxsw_core, struct sk_buff *skb, struct mlxsw_rx_info *rx_info) { … } EXPORT_SYMBOL(…); static int mlxsw_core_lag_mapping_index(struct mlxsw_core *mlxsw_core, u16 lag_id, u8 port_index) { … } void mlxsw_core_lag_mapping_set(struct mlxsw_core *mlxsw_core, u16 lag_id, u8 port_index, u16 local_port) { … } EXPORT_SYMBOL(…); u16 mlxsw_core_lag_mapping_get(struct mlxsw_core *mlxsw_core, u16 lag_id, u8 port_index) { … } EXPORT_SYMBOL(…); void mlxsw_core_lag_mapping_clear(struct mlxsw_core *mlxsw_core, u16 lag_id, u16 local_port) { … } EXPORT_SYMBOL(…); bool mlxsw_core_res_valid(struct mlxsw_core *mlxsw_core, enum mlxsw_res_id res_id) { … } EXPORT_SYMBOL(…); u64 mlxsw_core_res_get(struct mlxsw_core *mlxsw_core, enum mlxsw_res_id res_id) { … } EXPORT_SYMBOL(…); static const struct devlink_port_ops mlxsw_devlink_port_ops = …; static int __mlxsw_core_port_init(struct mlxsw_core *mlxsw_core, u16 local_port, enum devlink_port_flavour flavour, u8 slot_index, u32 port_number, bool split, u32 split_port_subnumber, bool splittable, u32 lanes, const unsigned char *switch_id, unsigned char switch_id_len) { … } static void __mlxsw_core_port_fini(struct mlxsw_core *mlxsw_core, u16 local_port) { … } int mlxsw_core_port_init(struct mlxsw_core *mlxsw_core, u16 local_port, u8 slot_index, u32 port_number, bool split, u32 split_port_subnumber, bool splittable, u32 lanes, const unsigned char *switch_id, unsigned char switch_id_len) { … } EXPORT_SYMBOL(…); void mlxsw_core_port_fini(struct mlxsw_core *mlxsw_core, u16 local_port) { … } EXPORT_SYMBOL(…); int mlxsw_core_cpu_port_init(struct mlxsw_core *mlxsw_core, void *port_driver_priv, const unsigned char *switch_id, unsigned char switch_id_len) { … } EXPORT_SYMBOL(…); void mlxsw_core_cpu_port_fini(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); void mlxsw_core_port_netdev_link(struct mlxsw_core *mlxsw_core, u16 local_port, void *port_driver_priv, struct net_device *dev) { … } EXPORT_SYMBOL(…); struct devlink_port * mlxsw_core_port_devlink_port_get(struct mlxsw_core *mlxsw_core, u16 local_port) { … } EXPORT_SYMBOL(…); struct mlxsw_linecard * mlxsw_core_port_linecard_get(struct mlxsw_core *mlxsw_core, u16 local_port) { … } void mlxsw_core_ports_remove_selected(struct mlxsw_core *mlxsw_core, bool (*selector)(void *priv, u16 local_port), void *priv) { … } struct mlxsw_env *mlxsw_core_env(const struct mlxsw_core *mlxsw_core) { … } static void mlxsw_core_buf_dump_dbg(struct mlxsw_core *mlxsw_core, const char *buf, size_t size) { … } int mlxsw_cmd_exec(struct mlxsw_core *mlxsw_core, u16 opcode, u8 opcode_mod, u32 in_mod, bool out_mbox_direct, bool reset_ok, char *in_mbox, size_t in_mbox_size, char *out_mbox, size_t out_mbox_size) { … } EXPORT_SYMBOL(…); int mlxsw_core_schedule_dw(struct delayed_work *dwork, unsigned long delay) { … } EXPORT_SYMBOL(…); bool mlxsw_core_schedule_work(struct work_struct *work) { … } EXPORT_SYMBOL(…); void mlxsw_core_flush_owq(void) { … } EXPORT_SYMBOL(…); int mlxsw_core_kvd_sizes_get(struct mlxsw_core *mlxsw_core, const struct mlxsw_config_profile *profile, u64 *p_single_size, u64 *p_double_size, u64 *p_linear_size) { … } EXPORT_SYMBOL(…); int mlxsw_core_resources_query(struct mlxsw_core *mlxsw_core, char *mbox, struct mlxsw_res *res) { … } EXPORT_SYMBOL(…); u32 mlxsw_core_read_frc_h(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); u32 mlxsw_core_read_frc_l(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); u32 mlxsw_core_read_utc_sec(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); u32 mlxsw_core_read_utc_nsec(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); bool mlxsw_core_sdq_supports_cqe_v2(struct mlxsw_core *mlxsw_core) { … } EXPORT_SYMBOL(…); static int __init mlxsw_core_module_init(void) { … } static void __exit mlxsw_core_module_exit(void) { … } module_init(…) …; module_exit(mlxsw_core_module_exit); MODULE_LICENSE(…) …; MODULE_AUTHOR(…) …; MODULE_DESCRIPTION(…) …;
Codebase Browser
linux