Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Jiri Pirko | 7100 | 95.98% | 29 | 55.77% |
Vadim Pasternak | 170 | 2.30% | 3 | 5.77% |
Arkadi Sharshevsky | 42 | 0.57% | 3 | 5.77% |
Ido Schimmel | 36 | 0.49% | 8 | 15.38% |
Yotam Gigi | 23 | 0.31% | 2 | 3.85% |
David Ahern | 10 | 0.14% | 1 | 1.92% |
Aleksandr Mishin | 6 | 0.08% | 1 | 1.92% |
Ivan Vecera | 4 | 0.05% | 1 | 1.92% |
Nogah Frankel | 2 | 0.03% | 1 | 1.92% |
Shalom Toledo | 2 | 0.03% | 1 | 1.92% |
Jakub Kiciński | 1 | 0.01% | 1 | 1.92% |
Elad Raz | 1 | 0.01% | 1 | 1.92% |
Total | 7397 | 52 |
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 /* Copyright (c) 2022 NVIDIA Corporation and Mellanox Technologies. All rights reserved */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/err.h> #include <linux/types.h> #include <linux/string.h> #include <linux/workqueue.h> #include <linux/gfp.h> #include <linux/slab.h> #include <linux/list.h> #include <linux/vmalloc.h> #include "core.h" #include "../mlxfw/mlxfw.h" struct mlxsw_linecard_ini_file { __le16 size; union { u8 data[0]; struct { __be16 hw_revision; __be16 ini_version; u8 __dontcare[3]; u8 type; u8 name[20]; } format; }; }; struct mlxsw_linecard_types_info { struct mlxsw_linecard_ini_file **ini_files; unsigned int count; size_t data_size; char *data; }; #define MLXSW_LINECARD_STATUS_EVENT_TO (10 * MSEC_PER_SEC) static void mlxsw_linecard_status_event_to_schedule(struct mlxsw_linecard *linecard, enum mlxsw_linecard_status_event_type status_event_type) { cancel_delayed_work_sync(&linecard->status_event_to_dw); linecard->status_event_type_to = status_event_type; mlxsw_core_schedule_dw(&linecard->status_event_to_dw, msecs_to_jiffies(MLXSW_LINECARD_STATUS_EVENT_TO)); } static void mlxsw_linecard_status_event_done(struct mlxsw_linecard *linecard, enum mlxsw_linecard_status_event_type status_event_type) { if (linecard->status_event_type_to == status_event_type) cancel_delayed_work_sync(&linecard->status_event_to_dw); } static const char * mlxsw_linecard_types_lookup(struct mlxsw_linecards *linecards, u8 card_type) { struct mlxsw_linecard_types_info *types_info; struct mlxsw_linecard_ini_file *ini_file; int i; types_info = linecards->types_info; if (!types_info) return NULL; for (i = 0; i < types_info->count; i++) { ini_file = linecards->types_info->ini_files[i]; if (ini_file->format.type == card_type) return ini_file->format.name; } return NULL; } static const char *mlxsw_linecard_type_name(struct mlxsw_linecard *linecard) { struct mlxsw_core *mlxsw_core = linecard->linecards->mlxsw_core; char mddq_pl[MLXSW_REG_MDDQ_LEN]; int err; mlxsw_reg_mddq_slot_name_pack(mddq_pl, linecard->slot_index); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mddq), mddq_pl); if (err) return ERR_PTR(err); mlxsw_reg_mddq_slot_name_unpack(mddq_pl, linecard->name); return linecard->name; } struct mlxsw_linecard_device_fw_info { struct mlxfw_dev mlxfw_dev; struct mlxsw_core *mlxsw_core; struct mlxsw_linecard *linecard; }; static int mlxsw_linecard_device_fw_component_query(struct mlxfw_dev *mlxfw_dev, u16 component_index, u32 *p_max_size, u8 *p_align_bits, u16 *p_max_write_size) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mcqi_pl; int err; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_QUERY, MLXSW_REG(mcqi), &mcqi_pl); mlxsw_reg_mcqi_pack(mcqi_pl, component_index); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mddt), mddt_pl); if (err) return err; mlxsw_reg_mcqi_unpack(mcqi_pl, p_max_size, p_align_bits, p_max_write_size); *p_align_bits = max_t(u8, *p_align_bits, 2); *p_max_write_size = min_t(u16, *p_max_write_size, MLXSW_REG_MCDA_MAX_DATA_LEN); return 0; } static int mlxsw_linecard_device_fw_fsm_lock(struct mlxfw_dev *mlxfw_dev, u32 *fwhandle) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; u8 control_state; char *mcc_pl; int err; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_QUERY, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, 0, 0, 0, 0); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mddt), mddt_pl); if (err) return err; mlxsw_reg_mcc_unpack(mcc_pl, fwhandle, NULL, &control_state); if (control_state != MLXFW_FSM_STATE_IDLE) return -EBUSY; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_WRITE, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_LOCK_UPDATE_HANDLE, 0, *fwhandle, 0); return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddt), mddt_pl); } static int mlxsw_linecard_device_fw_fsm_component_update(struct mlxfw_dev *mlxfw_dev, u32 fwhandle, u16 component_index, u32 component_size) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mcc_pl; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_WRITE, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_UPDATE_COMPONENT, component_index, fwhandle, component_size); return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddt), mddt_pl); } static int mlxsw_linecard_device_fw_fsm_block_download(struct mlxfw_dev *mlxfw_dev, u32 fwhandle, u8 *data, u16 size, u32 offset) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mcda_pl; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_WRITE, MLXSW_REG(mcda), &mcda_pl); mlxsw_reg_mcda_pack(mcda_pl, fwhandle, offset, size, data); return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddt), mddt_pl); } static int mlxsw_linecard_device_fw_fsm_component_verify(struct mlxfw_dev *mlxfw_dev, u32 fwhandle, u16 component_index) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mcc_pl; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_WRITE, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_VERIFY_COMPONENT, component_index, fwhandle, 0); return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddt), mddt_pl); } static int mlxsw_linecard_device_fw_fsm_activate(struct mlxfw_dev *mlxfw_dev, u32 fwhandle) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mcc_pl; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_WRITE, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_ACTIVATE, 0, fwhandle, 0); return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddt), mddt_pl); } static int mlxsw_linecard_device_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) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; u8 control_state; u8 error_code; char *mcc_pl; int err; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_QUERY, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, 0, 0, fwhandle, 0); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mddt), mddt_pl); if (err) return err; mlxsw_reg_mcc_unpack(mcc_pl, NULL, &error_code, &control_state); *fsm_state = control_state; *fsm_state_err = min_t(enum mlxfw_fsm_state_err, error_code, MLXFW_FSM_STATE_ERR_MAX); return 0; } static void mlxsw_linecard_device_fw_fsm_cancel(struct mlxfw_dev *mlxfw_dev, u32 fwhandle) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mcc_pl; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_WRITE, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_CANCEL, 0, fwhandle, 0); mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddt), mddt_pl); } static void mlxsw_linecard_device_fw_fsm_release(struct mlxfw_dev *mlxfw_dev, u32 fwhandle) { struct mlxsw_linecard_device_fw_info *info = container_of(mlxfw_dev, struct mlxsw_linecard_device_fw_info, mlxfw_dev); struct mlxsw_linecard *linecard = info->linecard; struct mlxsw_core *mlxsw_core = info->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mcc_pl; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, linecard->device.index, MLXSW_REG_MDDT_METHOD_WRITE, MLXSW_REG(mcc), &mcc_pl); mlxsw_reg_mcc_pack(mcc_pl, MLXSW_REG_MCC_INSTRUCTION_RELEASE_UPDATE_HANDLE, 0, fwhandle, 0); mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddt), mddt_pl); } static const struct mlxfw_dev_ops mlxsw_linecard_device_dev_ops = { .component_query = mlxsw_linecard_device_fw_component_query, .fsm_lock = mlxsw_linecard_device_fw_fsm_lock, .fsm_component_update = mlxsw_linecard_device_fw_fsm_component_update, .fsm_block_download = mlxsw_linecard_device_fw_fsm_block_download, .fsm_component_verify = mlxsw_linecard_device_fw_fsm_component_verify, .fsm_activate = mlxsw_linecard_device_fw_fsm_activate, .fsm_query_state = mlxsw_linecard_device_fw_fsm_query_state, .fsm_cancel = mlxsw_linecard_device_fw_fsm_cancel, .fsm_release = mlxsw_linecard_device_fw_fsm_release, }; int mlxsw_linecard_flash_update(struct devlink *linecard_devlink, struct mlxsw_linecard *linecard, const struct firmware *firmware, struct netlink_ext_ack *extack) { struct mlxsw_core *mlxsw_core = linecard->linecards->mlxsw_core; struct mlxsw_linecard_device_fw_info info = { .mlxfw_dev = { .ops = &mlxsw_linecard_device_dev_ops, .psid = linecard->device.info.psid, .psid_size = strlen(linecard->device.info.psid), .devlink = linecard_devlink, }, .mlxsw_core = mlxsw_core, .linecard = linecard, }; int err; mutex_lock(&linecard->lock); if (!linecard->active) { NL_SET_ERR_MSG_MOD(extack, "Only active line cards can be flashed"); err = -EINVAL; goto unlock; } err = mlxsw_core_fw_flash(mlxsw_core, &info.mlxfw_dev, firmware, extack); unlock: mutex_unlock(&linecard->lock); return err; } static int mlxsw_linecard_device_psid_get(struct mlxsw_linecard *linecard, u8 device_index, char *psid) { struct mlxsw_core *mlxsw_core = linecard->linecards->mlxsw_core; char mddt_pl[MLXSW_REG_MDDT_LEN]; char *mgir_pl; int err; mlxsw_reg_mddt_pack(mddt_pl, linecard->slot_index, device_index, MLXSW_REG_MDDT_METHOD_QUERY, MLXSW_REG(mgir), &mgir_pl); mlxsw_reg_mgir_pack(mgir_pl); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mddt), mddt_pl); if (err) return err; mlxsw_reg_mgir_fw_info_psid_memcpy_from(mgir_pl, psid); return 0; } static int mlxsw_linecard_device_info_update(struct mlxsw_linecard *linecard) { struct mlxsw_core *mlxsw_core = linecard->linecards->mlxsw_core; bool flashable_found = false; u8 msg_seq = 0; do { struct mlxsw_linecard_device_info info; char mddq_pl[MLXSW_REG_MDDQ_LEN]; bool flash_owner; bool data_valid; u8 device_index; int err; mlxsw_reg_mddq_device_info_pack(mddq_pl, linecard->slot_index, msg_seq); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mddq), mddq_pl); if (err) return err; mlxsw_reg_mddq_device_info_unpack(mddq_pl, &msg_seq, &data_valid, &flash_owner, &device_index, &info.fw_major, &info.fw_minor, &info.fw_sub_minor); if (!data_valid) break; if (!flash_owner) /* We care only about flashable ones. */ continue; if (flashable_found) { dev_warn_once(linecard->linecards->bus_info->dev, "linecard %u: More flashable devices present, exposing only the first one\n", linecard->slot_index); return 0; } err = mlxsw_linecard_device_psid_get(linecard, device_index, info.psid); if (err) return err; linecard->device.info = info; linecard->device.index = device_index; flashable_found = true; } while (msg_seq); return 0; } static void mlxsw_linecard_provision_fail(struct mlxsw_linecard *linecard) { linecard->provisioned = false; linecard->ready = false; linecard->active = false; devlink_linecard_provision_fail(linecard->devlink_linecard); } struct mlxsw_linecards_event_ops_item { struct list_head list; const struct mlxsw_linecards_event_ops *event_ops; void *priv; }; static void mlxsw_linecard_event_op_call(struct mlxsw_linecard *linecard, mlxsw_linecards_event_op_t *op, void *priv) { struct mlxsw_core *mlxsw_core = linecard->linecards->mlxsw_core; if (!op) return; op(mlxsw_core, linecard->slot_index, priv); } static void mlxsw_linecard_active_ops_call(struct mlxsw_linecard *linecard) { struct mlxsw_linecards *linecards = linecard->linecards; struct mlxsw_linecards_event_ops_item *item; mutex_lock(&linecards->event_ops_list_lock); list_for_each_entry(item, &linecards->event_ops_list, list) mlxsw_linecard_event_op_call(linecard, item->event_ops->got_active, item->priv); mutex_unlock(&linecards->event_ops_list_lock); } static void mlxsw_linecard_inactive_ops_call(struct mlxsw_linecard *linecard) { struct mlxsw_linecards *linecards = linecard->linecards; struct mlxsw_linecards_event_ops_item *item; mutex_lock(&linecards->event_ops_list_lock); list_for_each_entry(item, &linecards->event_ops_list, list) mlxsw_linecard_event_op_call(linecard, item->event_ops->got_inactive, item->priv); mutex_unlock(&linecards->event_ops_list_lock); } static void mlxsw_linecards_event_ops_register_call(struct mlxsw_linecards *linecards, const struct mlxsw_linecards_event_ops_item *item) { struct mlxsw_linecard *linecard; int i; for (i = 0; i < linecards->count; i++) { linecard = mlxsw_linecard_get(linecards, i + 1); mutex_lock(&linecard->lock); if (linecard->active) mlxsw_linecard_event_op_call(linecard, item->event_ops->got_active, item->priv); mutex_unlock(&linecard->lock); } } static void mlxsw_linecards_event_ops_unregister_call(struct mlxsw_linecards *linecards, const struct mlxsw_linecards_event_ops_item *item) { struct mlxsw_linecard *linecard; int i; for (i = 0; i < linecards->count; i++) { linecard = mlxsw_linecard_get(linecards, i + 1); mutex_lock(&linecard->lock); if (linecard->active) mlxsw_linecard_event_op_call(linecard, item->event_ops->got_inactive, item->priv); mutex_unlock(&linecard->lock); } } int mlxsw_linecards_event_ops_register(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards_event_ops *ops, void *priv) { struct mlxsw_linecards *linecards = mlxsw_core_linecards(mlxsw_core); struct mlxsw_linecards_event_ops_item *item; if (!linecards) return 0; item = kzalloc(sizeof(*item), GFP_KERNEL); if (!item) return -ENOMEM; item->event_ops = ops; item->priv = priv; mutex_lock(&linecards->event_ops_list_lock); list_add_tail(&item->list, &linecards->event_ops_list); mutex_unlock(&linecards->event_ops_list_lock); mlxsw_linecards_event_ops_register_call(linecards, item); return 0; } EXPORT_SYMBOL(mlxsw_linecards_event_ops_register); void mlxsw_linecards_event_ops_unregister(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards_event_ops *ops, void *priv) { struct mlxsw_linecards *linecards = mlxsw_core_linecards(mlxsw_core); struct mlxsw_linecards_event_ops_item *item, *tmp; bool found = false; if (!linecards) return; mutex_lock(&linecards->event_ops_list_lock); list_for_each_entry_safe(item, tmp, &linecards->event_ops_list, list) { if (item->event_ops == ops && item->priv == priv) { list_del(&item->list); found = true; break; } } mutex_unlock(&linecards->event_ops_list_lock); if (!found) return; mlxsw_linecards_event_ops_unregister_call(linecards, item); kfree(item); } EXPORT_SYMBOL(mlxsw_linecards_event_ops_unregister); int mlxsw_linecard_devlink_info_get(struct mlxsw_linecard *linecard, struct devlink_info_req *req, struct netlink_ext_ack *extack) { char buf[32]; int err; mutex_lock(&linecard->lock); if (WARN_ON(!linecard->provisioned)) { err = -EOPNOTSUPP; goto unlock; } sprintf(buf, "%d", linecard->hw_revision); err = devlink_info_version_fixed_put(req, "hw.revision", buf); if (err) goto unlock; sprintf(buf, "%d", linecard->ini_version); err = devlink_info_version_running_put(req, "ini.version", buf); if (err) goto unlock; if (linecard->active) { struct mlxsw_linecard_device_info *info = &linecard->device.info; err = devlink_info_version_fixed_put(req, DEVLINK_INFO_VERSION_GENERIC_FW_PSID, info->psid); sprintf(buf, "%u.%u.%u", info->fw_major, info->fw_minor, info->fw_sub_minor); err = devlink_info_version_running_put(req, DEVLINK_INFO_VERSION_GENERIC_FW, buf); if (err) goto unlock; } unlock: mutex_unlock(&linecard->lock); return err; } static int mlxsw_linecard_provision_set(struct mlxsw_linecard *linecard, u8 card_type, u16 hw_revision, u16 ini_version) { struct mlxsw_linecards *linecards = linecard->linecards; const char *type; int err; type = mlxsw_linecard_types_lookup(linecards, card_type); mlxsw_linecard_status_event_done(linecard, MLXSW_LINECARD_STATUS_EVENT_TYPE_PROVISION); if (!type) { /* It is possible for a line card to be provisioned before * driver initialization. Due to a missing INI bundle file * or an outdated one, the queried card's type might not * be recognized by the driver. In this case, try to query * the card's name from the device. */ type = mlxsw_linecard_type_name(linecard); if (IS_ERR(type)) { mlxsw_linecard_provision_fail(linecard); return PTR_ERR(type); } } linecard->provisioned = true; linecard->hw_revision = hw_revision; linecard->ini_version = ini_version; err = mlxsw_linecard_bdev_add(linecard); if (err) { linecard->provisioned = false; mlxsw_linecard_provision_fail(linecard); return err; } devlink_linecard_provision_set(linecard->devlink_linecard, type); return 0; } static void mlxsw_linecard_provision_clear(struct mlxsw_linecard *linecard) { mlxsw_linecard_status_event_done(linecard, MLXSW_LINECARD_STATUS_EVENT_TYPE_UNPROVISION); mlxsw_linecard_bdev_del(linecard); linecard->provisioned = false; devlink_linecard_provision_clear(linecard->devlink_linecard); } static int mlxsw_linecard_ready_set(struct mlxsw_linecard *linecard) { struct mlxsw_core *mlxsw_core = linecard->linecards->mlxsw_core; char mddc_pl[MLXSW_REG_MDDC_LEN]; int err; err = mlxsw_linecard_device_info_update(linecard); if (err) return err; mlxsw_reg_mddc_pack(mddc_pl, linecard->slot_index, false, true); err = mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddc), mddc_pl); if (err) return err; linecard->ready = true; return 0; } static int mlxsw_linecard_ready_clear(struct mlxsw_linecard *linecard) { struct mlxsw_core *mlxsw_core = linecard->linecards->mlxsw_core; char mddc_pl[MLXSW_REG_MDDC_LEN]; int err; mlxsw_reg_mddc_pack(mddc_pl, linecard->slot_index, false, false); err = mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddc), mddc_pl); if (err) return err; linecard->ready = false; return 0; } static void mlxsw_linecard_active_set(struct mlxsw_linecard *linecard) { mlxsw_linecard_active_ops_call(linecard); linecard->active = true; devlink_linecard_activate(linecard->devlink_linecard); } static void mlxsw_linecard_active_clear(struct mlxsw_linecard *linecard) { mlxsw_linecard_inactive_ops_call(linecard); linecard->active = false; devlink_linecard_deactivate(linecard->devlink_linecard); } static int mlxsw_linecard_status_process(struct mlxsw_linecards *linecards, struct mlxsw_linecard *linecard, const char *mddq_pl) { enum mlxsw_reg_mddq_slot_info_ready ready; bool provisioned, sr_valid, active; u16 ini_version, hw_revision; u8 slot_index, card_type; int err = 0; mlxsw_reg_mddq_slot_info_unpack(mddq_pl, &slot_index, &provisioned, &sr_valid, &ready, &active, &hw_revision, &ini_version, &card_type); if (linecard) { if (WARN_ON(slot_index != linecard->slot_index)) return -EINVAL; } else { if (WARN_ON(slot_index > linecards->count)) return -EINVAL; linecard = mlxsw_linecard_get(linecards, slot_index); } mutex_lock(&linecard->lock); if (provisioned && linecard->provisioned != provisioned) { err = mlxsw_linecard_provision_set(linecard, card_type, hw_revision, ini_version); if (err) goto out; } if (ready == MLXSW_REG_MDDQ_SLOT_INFO_READY_READY && !linecard->ready) { err = mlxsw_linecard_ready_set(linecard); if (err) goto out; } if (active && linecard->active != active) mlxsw_linecard_active_set(linecard); if (!active && linecard->active != active) mlxsw_linecard_active_clear(linecard); if (ready != MLXSW_REG_MDDQ_SLOT_INFO_READY_READY && linecard->ready) { err = mlxsw_linecard_ready_clear(linecard); if (err) goto out; } if (!provisioned && linecard->provisioned != provisioned) mlxsw_linecard_provision_clear(linecard); out: mutex_unlock(&linecard->lock); return err; } static int mlxsw_linecard_status_get_and_process(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards *linecards, struct mlxsw_linecard *linecard) { char mddq_pl[MLXSW_REG_MDDQ_LEN]; int err; mlxsw_reg_mddq_slot_info_pack(mddq_pl, linecard->slot_index, false); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mddq), mddq_pl); if (err) return err; return mlxsw_linecard_status_process(linecards, linecard, mddq_pl); } static void mlxsw_linecards_irq_event_handler(struct mlxsw_core *mlxsw_core) { struct mlxsw_linecards *linecards = mlxsw_core_linecards(mlxsw_core); int i; /* Handle change of line card active state. */ for (i = 0; i < linecards->count; i++) { struct mlxsw_linecard *linecard = mlxsw_linecard_get(linecards, i + 1); mlxsw_linecard_status_get_and_process(mlxsw_core, linecards, linecard); } } static const char * const mlxsw_linecard_status_event_type_name[] = { [MLXSW_LINECARD_STATUS_EVENT_TYPE_PROVISION] = "provision", [MLXSW_LINECARD_STATUS_EVENT_TYPE_UNPROVISION] = "unprovision", }; static void mlxsw_linecard_status_event_to_work(struct work_struct *work) { struct mlxsw_linecard *linecard = container_of(work, struct mlxsw_linecard, status_event_to_dw.work); mutex_lock(&linecard->lock); dev_err(linecard->linecards->bus_info->dev, "linecard %u: Timeout reached waiting on %s status event", linecard->slot_index, mlxsw_linecard_status_event_type_name[linecard->status_event_type_to]); mlxsw_linecard_provision_fail(linecard); mutex_unlock(&linecard->lock); } static int __mlxsw_linecard_fix_fsm_state(struct mlxsw_linecard *linecard) { dev_info(linecard->linecards->bus_info->dev, "linecard %u: Clearing FSM state error", linecard->slot_index); mlxsw_reg_mbct_pack(linecard->mbct_pl, linecard->slot_index, MLXSW_REG_MBCT_OP_CLEAR_ERRORS, false); return mlxsw_reg_write(linecard->linecards->mlxsw_core, MLXSW_REG(mbct), linecard->mbct_pl); } static int mlxsw_linecard_fix_fsm_state(struct mlxsw_linecard *linecard, enum mlxsw_reg_mbct_fsm_state fsm_state) { if (fsm_state != MLXSW_REG_MBCT_FSM_STATE_ERROR) return 0; return __mlxsw_linecard_fix_fsm_state(linecard); } static int mlxsw_linecard_query_ini_status(struct mlxsw_linecard *linecard, enum mlxsw_reg_mbct_status *status, enum mlxsw_reg_mbct_fsm_state *fsm_state, struct netlink_ext_ack *extack) { int err; mlxsw_reg_mbct_pack(linecard->mbct_pl, linecard->slot_index, MLXSW_REG_MBCT_OP_QUERY_STATUS, false); err = mlxsw_reg_query(linecard->linecards->mlxsw_core, MLXSW_REG(mbct), linecard->mbct_pl); if (err) { NL_SET_ERR_MSG_MOD(extack, "Failed to query linecard INI status"); return err; } mlxsw_reg_mbct_unpack(linecard->mbct_pl, NULL, status, fsm_state); return err; } static int mlxsw_linecard_ini_transfer(struct mlxsw_core *mlxsw_core, struct mlxsw_linecard *linecard, const struct mlxsw_linecard_ini_file *ini_file, struct netlink_ext_ack *extack) { enum mlxsw_reg_mbct_fsm_state fsm_state; enum mlxsw_reg_mbct_status status; size_t size_left; const u8 *data; int err; size_left = le16_to_cpu(ini_file->size); data = ini_file->data; while (size_left) { size_t data_size = MLXSW_REG_MBCT_DATA_LEN; bool is_last = false; if (size_left <= MLXSW_REG_MBCT_DATA_LEN) { data_size = size_left; is_last = true; } mlxsw_reg_mbct_pack(linecard->mbct_pl, linecard->slot_index, MLXSW_REG_MBCT_OP_DATA_TRANSFER, false); mlxsw_reg_mbct_dt_pack(linecard->mbct_pl, data_size, is_last, data); err = mlxsw_reg_write(mlxsw_core, MLXSW_REG(mbct), linecard->mbct_pl); if (err) { NL_SET_ERR_MSG_MOD(extack, "Failed to issue linecard INI data transfer"); return err; } mlxsw_reg_mbct_unpack(linecard->mbct_pl, NULL, &status, &fsm_state); if ((!is_last && status != MLXSW_REG_MBCT_STATUS_PART_DATA) || (is_last && status != MLXSW_REG_MBCT_STATUS_LAST_DATA)) { NL_SET_ERR_MSG_MOD(extack, "Failed to transfer linecard INI data"); mlxsw_linecard_fix_fsm_state(linecard, fsm_state); return -EINVAL; } size_left -= data_size; data += data_size; } return 0; } static int mlxsw_linecard_ini_erase(struct mlxsw_core *mlxsw_core, struct mlxsw_linecard *linecard, struct netlink_ext_ack *extack) { enum mlxsw_reg_mbct_fsm_state fsm_state; enum mlxsw_reg_mbct_status status; int err; mlxsw_reg_mbct_pack(linecard->mbct_pl, linecard->slot_index, MLXSW_REG_MBCT_OP_ERASE_INI_IMAGE, false); err = mlxsw_reg_write(mlxsw_core, MLXSW_REG(mbct), linecard->mbct_pl); if (err) { NL_SET_ERR_MSG_MOD(extack, "Failed to issue linecard INI erase"); return err; } mlxsw_reg_mbct_unpack(linecard->mbct_pl, NULL, &status, &fsm_state); switch (status) { case MLXSW_REG_MBCT_STATUS_ERASE_COMPLETE: break; default: /* Should not happen */ fallthrough; case MLXSW_REG_MBCT_STATUS_ERASE_FAILED: NL_SET_ERR_MSG_MOD(extack, "Failed to erase linecard INI"); goto fix_fsm_err_out; case MLXSW_REG_MBCT_STATUS_ERROR_INI_IN_USE: NL_SET_ERR_MSG_MOD(extack, "Failed to erase linecard INI while being used"); goto fix_fsm_err_out; } return 0; fix_fsm_err_out: mlxsw_linecard_fix_fsm_state(linecard, fsm_state); return -EINVAL; } static void mlxsw_linecard_bct_process(struct mlxsw_core *mlxsw_core, const char *mbct_pl) { struct mlxsw_linecards *linecards = mlxsw_core_linecards(mlxsw_core); enum mlxsw_reg_mbct_fsm_state fsm_state; enum mlxsw_reg_mbct_status status; struct mlxsw_linecard *linecard; u8 slot_index; mlxsw_reg_mbct_unpack(mbct_pl, &slot_index, &status, &fsm_state); if (WARN_ON(slot_index > linecards->count)) return; linecard = mlxsw_linecard_get(linecards, slot_index); mutex_lock(&linecard->lock); if (status == MLXSW_REG_MBCT_STATUS_ACTIVATION_FAILED) { dev_err(linecards->bus_info->dev, "linecard %u: Failed to activate INI", linecard->slot_index); goto fix_fsm_out; } mutex_unlock(&linecard->lock); return; fix_fsm_out: mlxsw_linecard_fix_fsm_state(linecard, fsm_state); mlxsw_linecard_provision_fail(linecard); mutex_unlock(&linecard->lock); } static int mlxsw_linecard_ini_activate(struct mlxsw_core *mlxsw_core, struct mlxsw_linecard *linecard, struct netlink_ext_ack *extack) { enum mlxsw_reg_mbct_fsm_state fsm_state; enum mlxsw_reg_mbct_status status; int err; mlxsw_reg_mbct_pack(linecard->mbct_pl, linecard->slot_index, MLXSW_REG_MBCT_OP_ACTIVATE, true); err = mlxsw_reg_write(mlxsw_core, MLXSW_REG(mbct), linecard->mbct_pl); if (err) { NL_SET_ERR_MSG_MOD(extack, "Failed to issue linecard INI activation"); return err; } mlxsw_reg_mbct_unpack(linecard->mbct_pl, NULL, &status, &fsm_state); if (status == MLXSW_REG_MBCT_STATUS_ACTIVATION_FAILED) { NL_SET_ERR_MSG_MOD(extack, "Failed to activate linecard INI"); goto fix_fsm_err_out; } return 0; fix_fsm_err_out: mlxsw_linecard_fix_fsm_state(linecard, fsm_state); return -EINVAL; } #define MLXSW_LINECARD_INI_WAIT_RETRIES 10 #define MLXSW_LINECARD_INI_WAIT_MS 500 static int mlxsw_linecard_ini_in_use_wait(struct mlxsw_core *mlxsw_core, struct mlxsw_linecard *linecard, struct netlink_ext_ack *extack) { enum mlxsw_reg_mbct_fsm_state fsm_state; enum mlxsw_reg_mbct_status status; unsigned int ini_wait_retries = 0; int err; query_ini_status: err = mlxsw_linecard_query_ini_status(linecard, &status, &fsm_state, extack); if (err) return err; switch (fsm_state) { case MLXSW_REG_MBCT_FSM_STATE_INI_IN_USE: if (ini_wait_retries++ > MLXSW_LINECARD_INI_WAIT_RETRIES) { NL_SET_ERR_MSG_MOD(extack, "Failed to wait for linecard INI to be unused"); return -EINVAL; } mdelay(MLXSW_LINECARD_INI_WAIT_MS); goto query_ini_status; default: break; } return 0; } static bool mlxsw_linecard_port_selector(void *priv, u16 local_port) { struct mlxsw_linecard *linecard = priv; struct mlxsw_core *mlxsw_core; mlxsw_core = linecard->linecards->mlxsw_core; return linecard == mlxsw_core_port_linecard_get(mlxsw_core, local_port); } static int mlxsw_linecard_provision(struct devlink_linecard *devlink_linecard, void *priv, const char *type, const void *type_priv, struct netlink_ext_ack *extack) { const struct mlxsw_linecard_ini_file *ini_file = type_priv; struct mlxsw_linecard *linecard = priv; struct mlxsw_core *mlxsw_core; int err; mutex_lock(&linecard->lock); mlxsw_core = linecard->linecards->mlxsw_core; err = mlxsw_linecard_ini_erase(mlxsw_core, linecard, extack); if (err) goto err_out; err = mlxsw_linecard_ini_transfer(mlxsw_core, linecard, ini_file, extack); if (err) goto err_out; mlxsw_linecard_status_event_to_schedule(linecard, MLXSW_LINECARD_STATUS_EVENT_TYPE_PROVISION); err = mlxsw_linecard_ini_activate(mlxsw_core, linecard, extack); if (err) goto err_out; goto out; err_out: mlxsw_linecard_provision_fail(linecard); out: mutex_unlock(&linecard->lock); return err; } static int mlxsw_linecard_unprovision(struct devlink_linecard *devlink_linecard, void *priv, struct netlink_ext_ack *extack) { struct mlxsw_linecard *linecard = priv; struct mlxsw_core *mlxsw_core; int err; mutex_lock(&linecard->lock); mlxsw_core = linecard->linecards->mlxsw_core; mlxsw_core_ports_remove_selected(mlxsw_core, mlxsw_linecard_port_selector, linecard); err = mlxsw_linecard_ini_in_use_wait(mlxsw_core, linecard, extack); if (err) goto err_out; mlxsw_linecard_status_event_to_schedule(linecard, MLXSW_LINECARD_STATUS_EVENT_TYPE_UNPROVISION); err = mlxsw_linecard_ini_erase(mlxsw_core, linecard, extack); if (err) goto err_out; goto out; err_out: mlxsw_linecard_provision_fail(linecard); out: mutex_unlock(&linecard->lock); return err; } static bool mlxsw_linecard_same_provision(struct devlink_linecard *devlink_linecard, void *priv, const char *type, const void *type_priv) { const struct mlxsw_linecard_ini_file *ini_file = type_priv; struct mlxsw_linecard *linecard = priv; bool ret; mutex_lock(&linecard->lock); ret = linecard->hw_revision == be16_to_cpu(ini_file->format.hw_revision) && linecard->ini_version == be16_to_cpu(ini_file->format.ini_version); mutex_unlock(&linecard->lock); return ret; } static unsigned int mlxsw_linecard_types_count(struct devlink_linecard *devlink_linecard, void *priv) { struct mlxsw_linecard *linecard = priv; return linecard->linecards->types_info ? linecard->linecards->types_info->count : 0; } static void mlxsw_linecard_types_get(struct devlink_linecard *devlink_linecard, void *priv, unsigned int index, const char **type, const void **type_priv) { struct mlxsw_linecard_types_info *types_info; struct mlxsw_linecard_ini_file *ini_file; struct mlxsw_linecard *linecard = priv; types_info = linecard->linecards->types_info; if (WARN_ON_ONCE(!types_info)) return; ini_file = types_info->ini_files[index]; *type = ini_file->format.name; *type_priv = ini_file; } static const struct devlink_linecard_ops mlxsw_linecard_ops = { .provision = mlxsw_linecard_provision, .unprovision = mlxsw_linecard_unprovision, .same_provision = mlxsw_linecard_same_provision, .types_count = mlxsw_linecard_types_count, .types_get = mlxsw_linecard_types_get, }; struct mlxsw_linecard_status_event { struct mlxsw_core *mlxsw_core; char mddq_pl[MLXSW_REG_MDDQ_LEN]; struct work_struct work; }; static void mlxsw_linecard_status_event_work(struct work_struct *work) { struct mlxsw_linecard_status_event *event; struct mlxsw_linecards *linecards; struct mlxsw_core *mlxsw_core; event = container_of(work, struct mlxsw_linecard_status_event, work); mlxsw_core = event->mlxsw_core; linecards = mlxsw_core_linecards(mlxsw_core); mlxsw_linecard_status_process(linecards, NULL, event->mddq_pl); kfree(event); } static void mlxsw_linecard_status_listener_func(const struct mlxsw_reg_info *reg, char *mddq_pl, void *priv) { struct mlxsw_linecard_status_event *event; struct mlxsw_core *mlxsw_core = priv; event = kmalloc(sizeof(*event), GFP_ATOMIC); if (!event) return; event->mlxsw_core = mlxsw_core; memcpy(event->mddq_pl, mddq_pl, sizeof(event->mddq_pl)); INIT_WORK(&event->work, mlxsw_linecard_status_event_work); mlxsw_core_schedule_work(&event->work); } struct mlxsw_linecard_bct_event { struct mlxsw_core *mlxsw_core; char mbct_pl[MLXSW_REG_MBCT_LEN]; struct work_struct work; }; static void mlxsw_linecard_bct_event_work(struct work_struct *work) { struct mlxsw_linecard_bct_event *event; struct mlxsw_core *mlxsw_core; event = container_of(work, struct mlxsw_linecard_bct_event, work); mlxsw_core = event->mlxsw_core; mlxsw_linecard_bct_process(mlxsw_core, event->mbct_pl); kfree(event); } static void mlxsw_linecard_bct_listener_func(const struct mlxsw_reg_info *reg, char *mbct_pl, void *priv) { struct mlxsw_linecard_bct_event *event; struct mlxsw_core *mlxsw_core = priv; event = kmalloc(sizeof(*event), GFP_ATOMIC); if (!event) return; event->mlxsw_core = mlxsw_core; memcpy(event->mbct_pl, mbct_pl, sizeof(event->mbct_pl)); INIT_WORK(&event->work, mlxsw_linecard_bct_event_work); mlxsw_core_schedule_work(&event->work); } static const struct mlxsw_listener mlxsw_linecard_listener[] = { MLXSW_CORE_EVENTL(mlxsw_linecard_status_listener_func, DSDSC), MLXSW_CORE_EVENTL(mlxsw_linecard_bct_listener_func, BCTOE), }; static int mlxsw_linecard_event_delivery_set(struct mlxsw_core *mlxsw_core, struct mlxsw_linecard *linecard, bool enable) { char mddq_pl[MLXSW_REG_MDDQ_LEN]; mlxsw_reg_mddq_slot_info_pack(mddq_pl, linecard->slot_index, enable); return mlxsw_reg_write(mlxsw_core, MLXSW_REG(mddq), mddq_pl); } static int mlxsw_linecard_init(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards *linecards, u8 slot_index) { struct devlink_linecard *devlink_linecard; struct mlxsw_linecard *linecard; linecard = mlxsw_linecard_get(linecards, slot_index); linecard->slot_index = slot_index; linecard->linecards = linecards; mutex_init(&linecard->lock); devlink_linecard = devl_linecard_create(priv_to_devlink(mlxsw_core), slot_index, &mlxsw_linecard_ops, linecard); if (IS_ERR(devlink_linecard)) return PTR_ERR(devlink_linecard); linecard->devlink_linecard = devlink_linecard; INIT_DELAYED_WORK(&linecard->status_event_to_dw, &mlxsw_linecard_status_event_to_work); return 0; } static void mlxsw_linecard_fini(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards *linecards, u8 slot_index) { struct mlxsw_linecard *linecard; linecard = mlxsw_linecard_get(linecards, slot_index); cancel_delayed_work_sync(&linecard->status_event_to_dw); /* Make sure all scheduled events are processed */ mlxsw_core_flush_owq(); if (linecard->active) mlxsw_linecard_active_clear(linecard); mlxsw_linecard_bdev_del(linecard); devl_linecard_destroy(linecard->devlink_linecard); mutex_destroy(&linecard->lock); } static int mlxsw_linecard_event_delivery_init(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards *linecards, u8 slot_index) { struct mlxsw_linecard *linecard; int err; linecard = mlxsw_linecard_get(linecards, slot_index); err = mlxsw_linecard_event_delivery_set(mlxsw_core, linecard, true); if (err) return err; err = mlxsw_linecard_status_get_and_process(mlxsw_core, linecards, linecard); if (err) goto err_status_get_and_process; return 0; err_status_get_and_process: mlxsw_linecard_event_delivery_set(mlxsw_core, linecard, false); return err; } static void mlxsw_linecard_event_delivery_fini(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards *linecards, u8 slot_index) { struct mlxsw_linecard *linecard; linecard = mlxsw_linecard_get(linecards, slot_index); mlxsw_linecard_event_delivery_set(mlxsw_core, linecard, false); } /* LINECARDS INI BUNDLE FILE * +----------------------------------+ * | MAGIC ("NVLCINI+") | * +----------------------------------+ +--------------------+ * | INI 0 +---> | __le16 size | * +----------------------------------+ | __be16 hw_revision | * | INI 1 | | __be16 ini_version | * +----------------------------------+ | u8 __dontcare[3] | * | ... | | u8 type | * +----------------------------------+ | u8 name[20] | * | INI N | | ... | * +----------------------------------+ +--------------------+ */ #define MLXSW_LINECARDS_INI_BUNDLE_MAGIC "NVLCINI+" static int mlxsw_linecard_types_file_validate(struct mlxsw_linecards *linecards, struct mlxsw_linecard_types_info *types_info) { size_t magic_size = strlen(MLXSW_LINECARDS_INI_BUNDLE_MAGIC); struct mlxsw_linecard_ini_file *ini_file; size_t size = types_info->data_size; const u8 *data = types_info->data; unsigned int count = 0; u16 ini_file_size; if (size < magic_size) { dev_warn(linecards->bus_info->dev, "Invalid linecards INIs file size, smaller than magic size\n"); return -EINVAL; } if (memcmp(data, MLXSW_LINECARDS_INI_BUNDLE_MAGIC, magic_size)) { dev_warn(linecards->bus_info->dev, "Invalid linecards INIs file magic pattern\n"); return -EINVAL; } data += magic_size; size -= magic_size; while (size > 0) { if (size < sizeof(*ini_file)) { dev_warn(linecards->bus_info->dev, "Linecards INIs file contains INI which is smaller than bare minimum\n"); return -EINVAL; } ini_file = (struct mlxsw_linecard_ini_file *) data; ini_file_size = le16_to_cpu(ini_file->size); if (ini_file_size + sizeof(__le16) > size) { dev_warn(linecards->bus_info->dev, "Linecards INIs file appears to be truncated\n"); return -EINVAL; } if (ini_file_size % 4) { dev_warn(linecards->bus_info->dev, "Linecards INIs file contains INI with invalid size\n"); return -EINVAL; } data += ini_file_size + sizeof(__le16); size -= ini_file_size + sizeof(__le16); count++; } if (!count) { dev_warn(linecards->bus_info->dev, "Linecards INIs file does not contain any INI\n"); return -EINVAL; } types_info->count = count; return 0; } static void mlxsw_linecard_types_file_parse(struct mlxsw_linecard_types_info *types_info) { size_t magic_size = strlen(MLXSW_LINECARDS_INI_BUNDLE_MAGIC); size_t size = types_info->data_size - magic_size; const u8 *data = types_info->data + magic_size; struct mlxsw_linecard_ini_file *ini_file; unsigned int count = 0; u16 ini_file_size; int i; while (size) { ini_file = (struct mlxsw_linecard_ini_file *) data; ini_file_size = le16_to_cpu(ini_file->size); for (i = 0; i < ini_file_size / 4; i++) { u32 *val = &((u32 *) ini_file->data)[i]; *val = swab32(*val); } types_info->ini_files[count] = ini_file; data += ini_file_size + sizeof(__le16); size -= ini_file_size + sizeof(__le16); count++; } } #define MLXSW_LINECARDS_INI_BUNDLE_FILENAME_FMT \ "mellanox/lc_ini_bundle_%u_%u.bin" #define MLXSW_LINECARDS_INI_BUNDLE_FILENAME_LEN \ (sizeof(MLXSW_LINECARDS_INI_BUNDLE_FILENAME_FMT) + 4) static int mlxsw_linecard_types_init(struct mlxsw_core *mlxsw_core, struct mlxsw_linecards *linecards) { const struct mlxsw_fw_rev *rev = &linecards->bus_info->fw_rev; char filename[MLXSW_LINECARDS_INI_BUNDLE_FILENAME_LEN]; struct mlxsw_linecard_types_info *types_info; const struct firmware *firmware; int err; err = snprintf(filename, sizeof(filename), MLXSW_LINECARDS_INI_BUNDLE_FILENAME_FMT, rev->minor, rev->subminor); WARN_ON(err >= sizeof(filename)); err = request_firmware_direct(&firmware, filename, linecards->bus_info->dev); if (err) { dev_warn(linecards->bus_info->dev, "Could not request linecards INI file \"%s\", provisioning will not be possible\n", filename); return 0; } types_info = kzalloc(sizeof(*types_info), GFP_KERNEL); if (!types_info) { release_firmware(firmware); return -ENOMEM; } linecards->types_info = types_info; types_info->data_size = firmware->size; types_info->data = vmalloc(types_info->data_size); if (!types_info->data) { err = -ENOMEM; release_firmware(firmware); goto err_data_alloc; } memcpy(types_info->data, firmware->data, types_info->data_size); release_firmware(firmware); err = mlxsw_linecard_types_file_validate(linecards, types_info); if (err) { err = 0; goto err_type_file_file_validate; } types_info->ini_files = kmalloc_array(types_info->count, sizeof(struct mlxsw_linecard_ini_file *), GFP_KERNEL); if (!types_info->ini_files) { err = -ENOMEM; goto err_ini_files_alloc; } mlxsw_linecard_types_file_parse(types_info); return 0; err_ini_files_alloc: err_type_file_file_validate: vfree(types_info->data); err_data_alloc: kfree(types_info); linecards->types_info = NULL; return err; } static void mlxsw_linecard_types_fini(struct mlxsw_linecards *linecards) { struct mlxsw_linecard_types_info *types_info = linecards->types_info; if (!types_info) return; kfree(types_info->ini_files); vfree(types_info->data); kfree(types_info); } int mlxsw_linecards_init(struct mlxsw_core *mlxsw_core, const struct mlxsw_bus_info *bus_info) { char mgpir_pl[MLXSW_REG_MGPIR_LEN]; struct mlxsw_linecards *linecards; u8 slot_count; int err; int i; mlxsw_reg_mgpir_pack(mgpir_pl, 0); err = mlxsw_reg_query(mlxsw_core, MLXSW_REG(mgpir), mgpir_pl); if (err) return err; mlxsw_reg_mgpir_unpack(mgpir_pl, NULL, NULL, NULL, NULL, &slot_count); if (!slot_count) return 0; linecards = vzalloc(struct_size(linecards, linecards, slot_count)); if (!linecards) return -ENOMEM; linecards->count = slot_count; linecards->mlxsw_core = mlxsw_core; linecards->bus_info = bus_info; INIT_LIST_HEAD(&linecards->event_ops_list); mutex_init(&linecards->event_ops_list_lock); err = mlxsw_linecard_types_init(mlxsw_core, linecards); if (err) goto err_types_init; err = mlxsw_core_traps_register(mlxsw_core, mlxsw_linecard_listener, ARRAY_SIZE(mlxsw_linecard_listener), mlxsw_core); if (err) goto err_traps_register; err = mlxsw_core_irq_event_handler_register(mlxsw_core, mlxsw_linecards_irq_event_handler); if (err) goto err_irq_event_handler_register; mlxsw_core_linecards_set(mlxsw_core, linecards); for (i = 0; i < linecards->count; i++) { err = mlxsw_linecard_init(mlxsw_core, linecards, i + 1); if (err) goto err_linecard_init; } for (i = 0; i < linecards->count; i++) { err = mlxsw_linecard_event_delivery_init(mlxsw_core, linecards, i + 1); if (err) goto err_linecard_event_delivery_init; } return 0; err_linecard_event_delivery_init: for (i--; i >= 0; i--) mlxsw_linecard_event_delivery_fini(mlxsw_core, linecards, i + 1); i = linecards->count; err_linecard_init: for (i--; i >= 0; i--) mlxsw_linecard_fini(mlxsw_core, linecards, i + 1); mlxsw_core_irq_event_handler_unregister(mlxsw_core, mlxsw_linecards_irq_event_handler); err_irq_event_handler_register: mlxsw_core_traps_unregister(mlxsw_core, mlxsw_linecard_listener, ARRAY_SIZE(mlxsw_linecard_listener), mlxsw_core); err_traps_register: mlxsw_linecard_types_fini(linecards); err_types_init: vfree(linecards); return err; } void mlxsw_linecards_fini(struct mlxsw_core *mlxsw_core) { struct mlxsw_linecards *linecards = mlxsw_core_linecards(mlxsw_core); int i; if (!linecards) return; for (i = 0; i < linecards->count; i++) mlxsw_linecard_event_delivery_fini(mlxsw_core, linecards, i + 1); for (i = 0; i < linecards->count; i++) mlxsw_linecard_fini(mlxsw_core, linecards, i + 1); mlxsw_core_irq_event_handler_unregister(mlxsw_core, mlxsw_linecards_irq_event_handler); mlxsw_core_traps_unregister(mlxsw_core, mlxsw_linecard_listener, ARRAY_SIZE(mlxsw_linecard_listener), mlxsw_core); mlxsw_linecard_types_fini(linecards); mutex_destroy(&linecards->event_ops_list_lock); WARN_ON(!list_empty(&linecards->event_ops_list)); vfree(linecards); }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1