1 // SPDX-License-Identifier: GPL-2.0 2 /* Huawei HiNIC PCI Express Linux driver 3 * Copyright(c) 2017 Huawei Technologies Co., Ltd 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * 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 WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * 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 23 static 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 63 static 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 else 96 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 102 static 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 122 static 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 242 static 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 281 static 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 290 static const struct devlink_ops hinic_devlink_ops = { 291 .flash_update = hinic_devlink_flash_update, 292 }; 293 294 struct devlink *hinic_devlink_alloc(struct device *dev) 295 { 296 return devlink_alloc(&hinic_devlink_ops, sizeof(struct hinic_dev), dev); 297 } 298 299 void hinic_devlink_free(struct devlink *devlink) 300 { 301 devlink_free(devlink); 302 } 303 304 void hinic_devlink_register(struct hinic_devlink_priv *priv) 305 { 306 struct devlink *devlink = priv_to_devlink(priv); 307 308 devlink_register(devlink); 309 } 310 311 void hinic_devlink_unregister(struct hinic_devlink_priv *priv) 312 { 313 struct devlink *devlink = priv_to_devlink(priv); 314 315 devlink_unregister(devlink); 316 } 317 318 static int 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 int err; 325 326 fault_level = (event->event.chip.err_level < FAULT_LEVEL_MAX) ? 327 event->event.chip.err_level : FAULT_LEVEL_MAX; 328 if (fault_level == FAULT_LEVEL_SERIOUS_FLR) { 329 err = devlink_fmsg_u32_pair_put(fmsg, "Function level err func_id", 330 (u32)event->event.chip.func_id); 331 if (err) 332 return err; 333 } 334 335 err = devlink_fmsg_u8_pair_put(fmsg, "module_id", event->event.chip.node_id); 336 if (err) 337 return err; 338 339 err = devlink_fmsg_u32_pair_put(fmsg, "err_type", (u32)event->event.chip.err_type); 340 if (err) 341 return err; 342 343 err = devlink_fmsg_string_pair_put(fmsg, "err_level", level_str[fault_level]); 344 if (err) 345 return err; 346 347 err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_addr", 348 event->event.chip.err_csr_addr); 349 if (err) 350 return err; 351 352 err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_value", 353 event->event.chip.err_csr_value); 354 if (err) 355 return err; 356 357 return 0; 358 } 359 360 static int fault_report_show(struct devlink_fmsg *fmsg, 361 struct hinic_fault_event *event) 362 { 363 const char * const type_str[FAULT_TYPE_MAX + 1] = { 364 "chip", "ucode", "mem rd timeout", "mem wr timeout", 365 "reg rd timeout", "reg wr timeout", "phy fault", "Unknown"}; 366 u8 fault_type; 367 int err; 368 369 fault_type = (event->type < FAULT_TYPE_MAX) ? event->type : FAULT_TYPE_MAX; 370 371 err = devlink_fmsg_string_pair_put(fmsg, "Fault type", type_str[fault_type]); 372 if (err) 373 return err; 374 375 err = devlink_fmsg_binary_pair_put(fmsg, "Fault raw data", 376 event->event.val, sizeof(event->event.val)); 377 if (err) 378 return err; 379 380 switch (event->type) { 381 case FAULT_TYPE_CHIP: 382 err = chip_fault_show(fmsg, event); 383 if (err) 384 return err; 385 break; 386 case FAULT_TYPE_UCODE: 387 err = devlink_fmsg_u8_pair_put(fmsg, "Cause_id", event->event.ucode.cause_id); 388 if (err) 389 return err; 390 err = devlink_fmsg_u8_pair_put(fmsg, "core_id", event->event.ucode.core_id); 391 if (err) 392 return err; 393 err = devlink_fmsg_u8_pair_put(fmsg, "c_id", event->event.ucode.c_id); 394 if (err) 395 return err; 396 err = devlink_fmsg_u8_pair_put(fmsg, "epc", event->event.ucode.epc); 397 if (err) 398 return err; 399 break; 400 case FAULT_TYPE_MEM_RD_TIMEOUT: 401 case FAULT_TYPE_MEM_WR_TIMEOUT: 402 err = devlink_fmsg_u32_pair_put(fmsg, "Err_csr_ctrl", 403 event->event.mem_timeout.err_csr_ctrl); 404 if (err) 405 return err; 406 err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_data", 407 event->event.mem_timeout.err_csr_data); 408 if (err) 409 return err; 410 err = devlink_fmsg_u32_pair_put(fmsg, "ctrl_tab", 411 event->event.mem_timeout.ctrl_tab); 412 if (err) 413 return err; 414 err = devlink_fmsg_u32_pair_put(fmsg, "mem_index", 415 event->event.mem_timeout.mem_index); 416 if (err) 417 return err; 418 break; 419 case FAULT_TYPE_REG_RD_TIMEOUT: 420 case FAULT_TYPE_REG_WR_TIMEOUT: 421 err = devlink_fmsg_u32_pair_put(fmsg, "Err_csr", event->event.reg_timeout.err_csr); 422 if (err) 423 return err; 424 break; 425 case FAULT_TYPE_PHY_FAULT: 426 err = devlink_fmsg_u8_pair_put(fmsg, "Op_type", event->event.phy_fault.op_type); 427 if (err) 428 return err; 429 err = devlink_fmsg_u8_pair_put(fmsg, "port_id", event->event.phy_fault.port_id); 430 if (err) 431 return err; 432 err = devlink_fmsg_u8_pair_put(fmsg, "dev_ad", event->event.phy_fault.dev_ad); 433 if (err) 434 return err; 435 436 err = devlink_fmsg_u32_pair_put(fmsg, "csr_addr", event->event.phy_fault.csr_addr); 437 if (err) 438 return err; 439 err = devlink_fmsg_u32_pair_put(fmsg, "op_data", event->event.phy_fault.op_data); 440 if (err) 441 return err; 442 break; 443 default: 444 break; 445 } 446 447 return 0; 448 } 449 450 static int hinic_hw_reporter_dump(struct devlink_health_reporter *reporter, 451 struct devlink_fmsg *fmsg, void *priv_ctx, 452 struct netlink_ext_ack *extack) 453 { 454 if (priv_ctx) 455 return fault_report_show(fmsg, priv_ctx); 456 457 return 0; 458 } 459 460 static int mgmt_watchdog_report_show(struct devlink_fmsg *fmsg, 461 struct hinic_mgmt_watchdog_info *watchdog_info) 462 { 463 int err; 464 465 err = devlink_fmsg_u32_pair_put(fmsg, "Mgmt deadloop time_h", watchdog_info->curr_time_h); 466 if (err) 467 return err; 468 469 err = devlink_fmsg_u32_pair_put(fmsg, "time_l", watchdog_info->curr_time_l); 470 if (err) 471 return err; 472 473 err = devlink_fmsg_u32_pair_put(fmsg, "task_id", watchdog_info->task_id); 474 if (err) 475 return err; 476 477 err = devlink_fmsg_u32_pair_put(fmsg, "sp", watchdog_info->sp); 478 if (err) 479 return err; 480 481 err = devlink_fmsg_u32_pair_put(fmsg, "stack_current_used", watchdog_info->curr_used); 482 if (err) 483 return err; 484 485 err = devlink_fmsg_u32_pair_put(fmsg, "peak_used", watchdog_info->peak_used); 486 if (err) 487 return err; 488 489 err = devlink_fmsg_u32_pair_put(fmsg, "\n Overflow_flag", watchdog_info->is_overflow); 490 if (err) 491 return err; 492 493 err = devlink_fmsg_u32_pair_put(fmsg, "stack_top", watchdog_info->stack_top); 494 if (err) 495 return err; 496 497 err = devlink_fmsg_u32_pair_put(fmsg, "stack_bottom", watchdog_info->stack_bottom); 498 if (err) 499 return err; 500 501 err = devlink_fmsg_u32_pair_put(fmsg, "mgmt_pc", watchdog_info->pc); 502 if (err) 503 return err; 504 505 err = devlink_fmsg_u32_pair_put(fmsg, "lr", watchdog_info->lr); 506 if (err) 507 return err; 508 509 err = devlink_fmsg_u32_pair_put(fmsg, "cpsr", watchdog_info->cpsr); 510 if (err) 511 return err; 512 513 err = devlink_fmsg_binary_pair_put(fmsg, "Mgmt register info", 514 watchdog_info->reg, sizeof(watchdog_info->reg)); 515 if (err) 516 return err; 517 518 err = devlink_fmsg_binary_pair_put(fmsg, "Mgmt dump stack(start from sp)", 519 watchdog_info->data, sizeof(watchdog_info->data)); 520 if (err) 521 return err; 522 523 return 0; 524 } 525 526 static int hinic_fw_reporter_dump(struct devlink_health_reporter *reporter, 527 struct devlink_fmsg *fmsg, void *priv_ctx, 528 struct netlink_ext_ack *extack) 529 { 530 if (priv_ctx) 531 return mgmt_watchdog_report_show(fmsg, priv_ctx); 532 533 return 0; 534 } 535 536 static const struct devlink_health_reporter_ops hinic_hw_fault_reporter_ops = { 537 .name = "hw", 538 .dump = hinic_hw_reporter_dump, 539 }; 540 541 static const struct devlink_health_reporter_ops hinic_fw_fault_reporter_ops = { 542 .name = "fw", 543 .dump = hinic_fw_reporter_dump, 544 }; 545 546 int hinic_health_reporters_create(struct hinic_devlink_priv *priv) 547 { 548 struct devlink *devlink = priv_to_devlink(priv); 549 550 priv->hw_fault_reporter = 551 devlink_health_reporter_create(devlink, &hinic_hw_fault_reporter_ops, 552 0, priv); 553 if (IS_ERR(priv->hw_fault_reporter)) { 554 dev_warn(&priv->hwdev->hwif->pdev->dev, "Failed to create hw fault reporter, err: %ld\n", 555 PTR_ERR(priv->hw_fault_reporter)); 556 return PTR_ERR(priv->hw_fault_reporter); 557 } 558 559 priv->fw_fault_reporter = 560 devlink_health_reporter_create(devlink, &hinic_fw_fault_reporter_ops, 561 0, priv); 562 if (IS_ERR(priv->fw_fault_reporter)) { 563 dev_warn(&priv->hwdev->hwif->pdev->dev, "Failed to create fw fault reporter, err: %ld\n", 564 PTR_ERR(priv->fw_fault_reporter)); 565 devlink_health_reporter_destroy(priv->hw_fault_reporter); 566 priv->hw_fault_reporter = NULL; 567 return PTR_ERR(priv->fw_fault_reporter); 568 } 569 570 return 0; 571 } 572 573 void hinic_health_reporters_destroy(struct hinic_devlink_priv *priv) 574 { 575 if (!IS_ERR_OR_NULL(priv->fw_fault_reporter)) { 576 devlink_health_reporter_destroy(priv->fw_fault_reporter); 577 priv->fw_fault_reporter = NULL; 578 } 579 580 if (!IS_ERR_OR_NULL(priv->hw_fault_reporter)) { 581 devlink_health_reporter_destroy(priv->hw_fault_reporter); 582 priv->hw_fault_reporter = NULL; 583 } 584 } 585