480 lines · c
1// SPDX-License-Identifier: GPL-2.02/* Huawei HiNIC PCI Express Linux driver3 * Copyright(c) 2017 Huawei Technologies Co., Ltd4 *5 * This program is free software; you can redistribute it and/or modify it6 * under the terms and conditions of the GNU General Public License,7 * version 2, as published by the Free Software Foundation.8 *9 * This program is distributed in the hope it will be useful, but WITHOUT10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License12 * for more details.13 *14 */15#include <linux/netlink.h>16#include <net/devlink.h>17#include <linux/firmware.h>18 19#include "hinic_port.h"20#include "hinic_devlink.h"21#include "hinic_hw_dev.h"22 23static bool check_image_valid(struct hinic_devlink_priv *priv, const u8 *buf,24 u32 image_size, struct host_image_st *host_image)25{26 struct fw_image_st *fw_image = NULL;27 u32 len = 0;28 u32 i;29 30 fw_image = (struct fw_image_st *)buf;31 32 if (fw_image->fw_magic != HINIC_MAGIC_NUM) {33 dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong fw_magic read from file, fw_magic: 0x%x\n",34 fw_image->fw_magic);35 return false;36 }37 38 if (fw_image->fw_info.fw_section_cnt > MAX_FW_TYPE_NUM) {39 dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong fw_type_num read from file, fw_type_num: 0x%x\n",40 fw_image->fw_info.fw_section_cnt);41 return false;42 }43 44 for (i = 0; i < fw_image->fw_info.fw_section_cnt; i++) {45 len += fw_image->fw_section_info[i].fw_section_len;46 host_image->image_section_info[i] = fw_image->fw_section_info[i];47 }48 49 if (len != fw_image->fw_len ||50 (fw_image->fw_len + UPDATEFW_IMAGE_HEAD_SIZE) != image_size) {51 dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong data size read from file\n");52 return false;53 }54 55 host_image->image_info.up_total_len = fw_image->fw_len;56 host_image->image_info.fw_version = fw_image->fw_version;57 host_image->section_type_num = fw_image->fw_info.fw_section_cnt;58 host_image->device_id = fw_image->device_id;59 60 return true;61}62 63static bool check_image_integrity(struct hinic_devlink_priv *priv,64 struct host_image_st *host_image,65 u32 update_type)66{67 u32 collect_section_type = 0;68 u32 i, type;69 70 for (i = 0; i < host_image->section_type_num; i++) {71 type = host_image->image_section_info[i].fw_section_type;72 if (collect_section_type & (1U << type)) {73 dev_err(&priv->hwdev->hwif->pdev->dev, "Duplicate section type: %u\n",74 type);75 return false;76 }77 collect_section_type |= (1U << type);78 }79 80 if (update_type == FW_UPDATE_COLD &&81 (((collect_section_type & _IMAGE_COLD_SUB_MODULES_MUST_IN) ==82 _IMAGE_COLD_SUB_MODULES_MUST_IN) ||83 collect_section_type == _IMAGE_CFG_SUB_MODULES_MUST_IN))84 return true;85 86 if (update_type == FW_UPDATE_HOT &&87 (collect_section_type & _IMAGE_HOT_SUB_MODULES_MUST_IN) ==88 _IMAGE_HOT_SUB_MODULES_MUST_IN)89 return true;90 91 if (update_type == FW_UPDATE_COLD)92 dev_err(&priv->hwdev->hwif->pdev->dev, "Check file integrity failed, valid: 0x%x or 0x%lx, current: 0x%x\n",93 _IMAGE_COLD_SUB_MODULES_MUST_IN,94 _IMAGE_CFG_SUB_MODULES_MUST_IN, collect_section_type);95 else96 dev_err(&priv->hwdev->hwif->pdev->dev, "Check file integrity failed, valid:0x%x, current: 0x%x\n",97 _IMAGE_HOT_SUB_MODULES_MUST_IN, collect_section_type);98 99 return false;100}101 102static int check_image_device_type(struct hinic_devlink_priv *priv,103 u32 image_device_type)104{105 struct hinic_comm_board_info board_info = {0};106 107 if (hinic_get_board_info(priv->hwdev, &board_info)) {108 dev_err(&priv->hwdev->hwif->pdev->dev, "Get board info failed\n");109 return false;110 }111 112 if (image_device_type == board_info.info.board_type)113 return true;114 115 dev_err(&priv->hwdev->hwif->pdev->dev, "The device type of upgrade file doesn't match the device type of current firmware, please check the upgrade file\n");116 dev_err(&priv->hwdev->hwif->pdev->dev, "The image device type: 0x%x, firmware device type: 0x%x\n",117 image_device_type, board_info.info.board_type);118 119 return false;120}121 122static int hinic_flash_fw(struct hinic_devlink_priv *priv, const u8 *data,123 struct host_image_st *host_image)124{125 u32 section_remain_send_len, send_fragment_len, send_pos, up_total_len;126 struct hinic_cmd_update_fw *fw_update_msg = NULL;127 u32 section_type, section_crc, section_version;128 u32 i, len, section_len, section_offset;129 u16 out_size = sizeof(*fw_update_msg);130 int total_len_flag = 0;131 int err;132 133 fw_update_msg = kzalloc(sizeof(*fw_update_msg), GFP_KERNEL);134 if (!fw_update_msg)135 return -ENOMEM;136 137 up_total_len = host_image->image_info.up_total_len;138 139 for (i = 0; i < host_image->section_type_num; i++) {140 len = host_image->image_section_info[i].fw_section_len;141 if (host_image->image_section_info[i].fw_section_type ==142 UP_FW_UPDATE_BOOT) {143 up_total_len = up_total_len - len;144 break;145 }146 }147 148 for (i = 0; i < host_image->section_type_num; i++) {149 section_len =150 host_image->image_section_info[i].fw_section_len;151 section_offset =152 host_image->image_section_info[i].fw_section_offset;153 section_remain_send_len = section_len;154 section_type =155 host_image->image_section_info[i].fw_section_type;156 section_crc = host_image->image_section_info[i].fw_section_crc;157 section_version =158 host_image->image_section_info[i].fw_section_version;159 160 if (section_type == UP_FW_UPDATE_BOOT)161 continue;162 163 send_fragment_len = 0;164 send_pos = 0;165 166 while (section_remain_send_len > 0) {167 if (!total_len_flag) {168 fw_update_msg->total_len = up_total_len;169 total_len_flag = 1;170 } else {171 fw_update_msg->total_len = 0;172 }173 174 memset(fw_update_msg->data, 0, MAX_FW_FRAGMENT_LEN);175 176 fw_update_msg->ctl_info.SF =177 (section_remain_send_len == section_len) ?178 true : false;179 fw_update_msg->section_info.FW_section_CRC = section_crc;180 fw_update_msg->fw_section_version = section_version;181 fw_update_msg->ctl_info.flag = UP_TYPE_A;182 183 if (section_type <= UP_FW_UPDATE_UP_DATA_B) {184 fw_update_msg->section_info.FW_section_type =185 (section_type % 2) ?186 UP_FW_UPDATE_UP_DATA :187 UP_FW_UPDATE_UP_TEXT;188 189 fw_update_msg->ctl_info.flag = UP_TYPE_B;190 if (section_type <= UP_FW_UPDATE_UP_DATA_A)191 fw_update_msg->ctl_info.flag = UP_TYPE_A;192 } else {193 fw_update_msg->section_info.FW_section_type =194 section_type - 0x2;195 }196 197 fw_update_msg->setion_total_len = section_len;198 fw_update_msg->section_offset = send_pos;199 200 if (section_remain_send_len <= MAX_FW_FRAGMENT_LEN) {201 fw_update_msg->ctl_info.SL = true;202 fw_update_msg->ctl_info.fragment_len =203 section_remain_send_len;204 send_fragment_len += section_remain_send_len;205 } else {206 fw_update_msg->ctl_info.SL = false;207 fw_update_msg->ctl_info.fragment_len =208 MAX_FW_FRAGMENT_LEN;209 send_fragment_len += MAX_FW_FRAGMENT_LEN;210 }211 212 memcpy(fw_update_msg->data,213 data + UPDATEFW_IMAGE_HEAD_SIZE +214 section_offset + send_pos,215 fw_update_msg->ctl_info.fragment_len);216 217 err = hinic_port_msg_cmd(priv->hwdev,218 HINIC_PORT_CMD_UPDATE_FW,219 fw_update_msg,220 sizeof(*fw_update_msg),221 fw_update_msg, &out_size);222 if (err || !out_size || fw_update_msg->status) {223 dev_err(&priv->hwdev->hwif->pdev->dev, "Failed to update firmware, err: %d, status: 0x%x, out size: 0x%x\n",224 err, fw_update_msg->status, out_size);225 err = fw_update_msg->status ?226 fw_update_msg->status : -EIO;227 kfree(fw_update_msg);228 return err;229 }230 231 send_pos = send_fragment_len;232 section_remain_send_len = section_len -233 send_fragment_len;234 }235 }236 237 kfree(fw_update_msg);238 239 return 0;240}241 242static int hinic_firmware_update(struct hinic_devlink_priv *priv,243 const struct firmware *fw,244 struct netlink_ext_ack *extack)245{246 struct host_image_st host_image;247 int err;248 249 memset(&host_image, 0, sizeof(struct host_image_st));250 251 if (!check_image_valid(priv, fw->data, fw->size, &host_image) ||252 !check_image_integrity(priv, &host_image, FW_UPDATE_COLD) ||253 !check_image_device_type(priv, host_image.device_id)) {254 NL_SET_ERR_MSG_MOD(extack, "Check image failed");255 return -EINVAL;256 }257 258 dev_info(&priv->hwdev->hwif->pdev->dev, "Flash firmware begin\n");259 260 err = hinic_flash_fw(priv, fw->data, &host_image);261 if (err) {262 if (err == HINIC_FW_DISMATCH_ERROR) {263 dev_err(&priv->hwdev->hwif->pdev->dev, "Firmware image doesn't match this card, please use newer image, err: %d\n",264 err);265 NL_SET_ERR_MSG_MOD(extack,266 "Firmware image doesn't match this card, please use newer image");267 } else {268 dev_err(&priv->hwdev->hwif->pdev->dev, "Send firmware image data failed, err: %d\n",269 err);270 NL_SET_ERR_MSG_MOD(extack, "Send firmware image data failed");271 }272 273 return err;274 }275 276 dev_info(&priv->hwdev->hwif->pdev->dev, "Flash firmware end\n");277 278 return 0;279}280 281static int hinic_devlink_flash_update(struct devlink *devlink,282 struct devlink_flash_update_params *params,283 struct netlink_ext_ack *extack)284{285 struct hinic_devlink_priv *priv = devlink_priv(devlink);286 287 return hinic_firmware_update(priv, params->fw, extack);288}289 290static const struct devlink_ops hinic_devlink_ops = {291 .flash_update = hinic_devlink_flash_update,292};293 294struct devlink *hinic_devlink_alloc(struct device *dev)295{296 return devlink_alloc(&hinic_devlink_ops, sizeof(struct hinic_dev), dev);297}298 299void hinic_devlink_free(struct devlink *devlink)300{301 devlink_free(devlink);302}303 304void hinic_devlink_register(struct hinic_devlink_priv *priv)305{306 struct devlink *devlink = priv_to_devlink(priv);307 308 devlink_register(devlink);309}310 311void hinic_devlink_unregister(struct hinic_devlink_priv *priv)312{313 struct devlink *devlink = priv_to_devlink(priv);314 315 devlink_unregister(devlink);316}317 318static void chip_fault_show(struct devlink_fmsg *fmsg,319 struct hinic_fault_event *event)320{321 const char * const level_str[FAULT_LEVEL_MAX + 1] = {322 "fatal", "reset", "flr", "general", "suggestion", "Unknown"};323 u8 fault_level;324 325 fault_level = (event->event.chip.err_level < FAULT_LEVEL_MAX) ?326 event->event.chip.err_level : FAULT_LEVEL_MAX;327 if (fault_level == FAULT_LEVEL_SERIOUS_FLR)328 devlink_fmsg_u32_pair_put(fmsg, "Function level err func_id",329 (u32)event->event.chip.func_id);330 devlink_fmsg_u8_pair_put(fmsg, "module_id", event->event.chip.node_id);331 devlink_fmsg_u32_pair_put(fmsg, "err_type", (u32)event->event.chip.err_type);332 devlink_fmsg_string_pair_put(fmsg, "err_level", level_str[fault_level]);333 devlink_fmsg_u32_pair_put(fmsg, "err_csr_addr",334 event->event.chip.err_csr_addr);335 devlink_fmsg_u32_pair_put(fmsg, "err_csr_value",336 event->event.chip.err_csr_value);337}338 339static void fault_report_show(struct devlink_fmsg *fmsg,340 struct hinic_fault_event *event)341{342 const char * const type_str[FAULT_TYPE_MAX + 1] = {343 "chip", "ucode", "mem rd timeout", "mem wr timeout",344 "reg rd timeout", "reg wr timeout", "phy fault", "Unknown"};345 u8 fault_type;346 347 fault_type = (event->type < FAULT_TYPE_MAX) ? event->type : FAULT_TYPE_MAX;348 349 devlink_fmsg_string_pair_put(fmsg, "Fault type", type_str[fault_type]);350 devlink_fmsg_binary_pair_put(fmsg, "Fault raw data", event->event.val,351 sizeof(event->event.val));352 353 switch (event->type) {354 case FAULT_TYPE_CHIP:355 chip_fault_show(fmsg, event);356 break;357 case FAULT_TYPE_UCODE:358 devlink_fmsg_u8_pair_put(fmsg, "Cause_id", event->event.ucode.cause_id);359 devlink_fmsg_u8_pair_put(fmsg, "core_id", event->event.ucode.core_id);360 devlink_fmsg_u8_pair_put(fmsg, "c_id", event->event.ucode.c_id);361 devlink_fmsg_u8_pair_put(fmsg, "epc", event->event.ucode.epc);362 break;363 case FAULT_TYPE_MEM_RD_TIMEOUT:364 case FAULT_TYPE_MEM_WR_TIMEOUT:365 devlink_fmsg_u32_pair_put(fmsg, "Err_csr_ctrl",366 event->event.mem_timeout.err_csr_ctrl);367 devlink_fmsg_u32_pair_put(fmsg, "err_csr_data",368 event->event.mem_timeout.err_csr_data);369 devlink_fmsg_u32_pair_put(fmsg, "ctrl_tab",370 event->event.mem_timeout.ctrl_tab);371 devlink_fmsg_u32_pair_put(fmsg, "mem_index",372 event->event.mem_timeout.mem_index);373 break;374 case FAULT_TYPE_REG_RD_TIMEOUT:375 case FAULT_TYPE_REG_WR_TIMEOUT:376 devlink_fmsg_u32_pair_put(fmsg, "Err_csr", event->event.reg_timeout.err_csr);377 break;378 case FAULT_TYPE_PHY_FAULT:379 devlink_fmsg_u8_pair_put(fmsg, "Op_type", event->event.phy_fault.op_type);380 devlink_fmsg_u8_pair_put(fmsg, "port_id", event->event.phy_fault.port_id);381 devlink_fmsg_u8_pair_put(fmsg, "dev_ad", event->event.phy_fault.dev_ad);382 devlink_fmsg_u32_pair_put(fmsg, "csr_addr", event->event.phy_fault.csr_addr);383 devlink_fmsg_u32_pair_put(fmsg, "op_data", event->event.phy_fault.op_data);384 break;385 default:386 break;387 }388}389 390static int hinic_hw_reporter_dump(struct devlink_health_reporter *reporter,391 struct devlink_fmsg *fmsg, void *priv_ctx,392 struct netlink_ext_ack *extack)393{394 if (priv_ctx)395 fault_report_show(fmsg, priv_ctx);396 397 return 0;398}399 400static void mgmt_watchdog_report_show(struct devlink_fmsg *fmsg,401 struct hinic_mgmt_watchdog_info *winfo)402{403 devlink_fmsg_u32_pair_put(fmsg, "Mgmt deadloop time_h", winfo->curr_time_h);404 devlink_fmsg_u32_pair_put(fmsg, "time_l", winfo->curr_time_l);405 devlink_fmsg_u32_pair_put(fmsg, "task_id", winfo->task_id);406 devlink_fmsg_u32_pair_put(fmsg, "sp", winfo->sp);407 devlink_fmsg_u32_pair_put(fmsg, "stack_current_used", winfo->curr_used);408 devlink_fmsg_u32_pair_put(fmsg, "peak_used", winfo->peak_used);409 devlink_fmsg_u32_pair_put(fmsg, "\n Overflow_flag", winfo->is_overflow);410 devlink_fmsg_u32_pair_put(fmsg, "stack_top", winfo->stack_top);411 devlink_fmsg_u32_pair_put(fmsg, "stack_bottom", winfo->stack_bottom);412 devlink_fmsg_u32_pair_put(fmsg, "mgmt_pc", winfo->pc);413 devlink_fmsg_u32_pair_put(fmsg, "lr", winfo->lr);414 devlink_fmsg_u32_pair_put(fmsg, "cpsr", winfo->cpsr);415 devlink_fmsg_binary_pair_put(fmsg, "Mgmt register info", winfo->reg,416 sizeof(winfo->reg));417 devlink_fmsg_binary_pair_put(fmsg, "Mgmt dump stack(start from sp)",418 winfo->data, sizeof(winfo->data));419}420 421static int hinic_fw_reporter_dump(struct devlink_health_reporter *reporter,422 struct devlink_fmsg *fmsg, void *priv_ctx,423 struct netlink_ext_ack *extack)424{425 if (priv_ctx)426 mgmt_watchdog_report_show(fmsg, priv_ctx);427 428 return 0;429}430 431static const struct devlink_health_reporter_ops hinic_hw_fault_reporter_ops = {432 .name = "hw",433 .dump = hinic_hw_reporter_dump,434};435 436static const struct devlink_health_reporter_ops hinic_fw_fault_reporter_ops = {437 .name = "fw",438 .dump = hinic_fw_reporter_dump,439};440 441int hinic_health_reporters_create(struct hinic_devlink_priv *priv)442{443 struct devlink *devlink = priv_to_devlink(priv);444 445 priv->hw_fault_reporter =446 devlink_health_reporter_create(devlink, &hinic_hw_fault_reporter_ops,447 0, priv);448 if (IS_ERR(priv->hw_fault_reporter)) {449 dev_warn(&priv->hwdev->hwif->pdev->dev, "Failed to create hw fault reporter, err: %ld\n",450 PTR_ERR(priv->hw_fault_reporter));451 return PTR_ERR(priv->hw_fault_reporter);452 }453 454 priv->fw_fault_reporter =455 devlink_health_reporter_create(devlink, &hinic_fw_fault_reporter_ops,456 0, priv);457 if (IS_ERR(priv->fw_fault_reporter)) {458 dev_warn(&priv->hwdev->hwif->pdev->dev, "Failed to create fw fault reporter, err: %ld\n",459 PTR_ERR(priv->fw_fault_reporter));460 devlink_health_reporter_destroy(priv->hw_fault_reporter);461 priv->hw_fault_reporter = NULL;462 return PTR_ERR(priv->fw_fault_reporter);463 }464 465 return 0;466}467 468void hinic_health_reporters_destroy(struct hinic_devlink_priv *priv)469{470 if (!IS_ERR_OR_NULL(priv->fw_fault_reporter)) {471 devlink_health_reporter_destroy(priv->fw_fault_reporter);472 priv->fw_fault_reporter = NULL;473 }474 475 if (!IS_ERR_OR_NULL(priv->hw_fault_reporter)) {476 devlink_health_reporter_destroy(priv->hw_fault_reporter);477 priv->hw_fault_reporter = NULL;478 }479}480