Commit 5e126e7c authored by Luo bin's avatar Luo bin Committed by Jakub Kicinski
Browse files

hinic: add firmware update support 



add support to update firmware by the devlink flashing API

Signed-off-by: default avatarLuo bin <luobin9@huawei.com>
Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 514d0952

drivers/net/ethernet/huawei/hinic/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -4,4 +4,4 @@ obj-$(CONFIG_HINIC) += hinic.o 
hinic-y := hinic_main.o hinic_tx.o hinic_rx.o hinic_port.o hinic_hw_dev.o \

	   hinic_hw_io.o hinic_hw_qp.o hinic_hw_cmdq.o hinic_hw_wq.o \

	   hinic_hw_mgmt.o hinic_hw_api_cmd.o hinic_hw_eqs.o hinic_hw_if.o \

	   hinic_common.o hinic_ethtool.o hinic_hw_mbox.o hinic_sriov.o
 
	   hinic_common.o hinic_ethtool.o hinic_devlink.o hinic_hw_mbox.o hinic_sriov.o

drivers/net/ethernet/huawei/hinic/hinic_dev.h

+5 −0
Original line number Diff line number Diff line
@@ -97,6 +97,11 @@ struct hinic_dev { 
	int				lb_test_rx_idx;

	int				lb_pkt_len;

	u8				*lb_test_rx_buf;

	struct devlink			*devlink;

};



struct hinic_devlink_priv {

	struct hinic_hwdev		*hwdev;

};



#endif

drivers/net/ethernet/huawei/hinic/hinic_devlink.c

0 → 100644
+328 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Huawei HiNIC PCI Express Linux driver

 * Copyright(c) 2017 Huawei Technologies Co., Ltd

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * for more details.

 *

 */

#include <linux/netlink.h>

#include <net/devlink.h>

#include <linux/firmware.h>



#include "hinic_dev.h"

#include "hinic_port.h"

#include "hinic_devlink.h"



static bool check_image_valid(struct hinic_devlink_priv *priv, const u8 *buf,

			      u32 image_size, struct host_image_st *host_image)

{

	struct fw_image_st *fw_image = NULL;

	u32 len = 0;

	u32 i;



	fw_image = (struct fw_image_st *)buf;



	if (fw_image->fw_magic != HINIC_MAGIC_NUM) {

		dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong fw_magic read from file, fw_magic: 0x%x\n",

			fw_image->fw_magic);

		return false;

	}



	if (fw_image->fw_info.fw_section_cnt > MAX_FW_TYPE_NUM) {

		dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong fw_type_num read from file, fw_type_num: 0x%x\n",

			fw_image->fw_info.fw_section_cnt);

		return false;

	}



	for (i = 0; i < fw_image->fw_info.fw_section_cnt; i++) {

		len += fw_image->fw_section_info[i].fw_section_len;

		memcpy(&host_image->image_section_info[i],

		       &fw_image->fw_section_info[i],

		       sizeof(struct fw_section_info_st));

	}



	if (len != fw_image->fw_len ||

	    (fw_image->fw_len + UPDATEFW_IMAGE_HEAD_SIZE) != image_size) {

		dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong data size read from file\n");

		return false;

	}



	host_image->image_info.up_total_len = fw_image->fw_len;

	host_image->image_info.fw_version = fw_image->fw_version;

	host_image->section_type_num = fw_image->fw_info.fw_section_cnt;

	host_image->device_id = fw_image->device_id;



	return true;

}



static bool check_image_integrity(struct hinic_devlink_priv *priv,

				  struct host_image_st *host_image,

				  u32 update_type)

{

	u32 collect_section_type = 0;

	u32 i, type;



	for (i = 0; i < host_image->section_type_num; i++) {

		type = host_image->image_section_info[i].fw_section_type;

		if (collect_section_type & (1U << type)) {

			dev_err(&priv->hwdev->hwif->pdev->dev, "Duplicate section type: %u\n",

				type);

			return false;

		}

		collect_section_type |= (1U << type);

	}



	if (update_type == FW_UPDATE_COLD &&

	    (((collect_section_type & _IMAGE_COLD_SUB_MODULES_MUST_IN) ==

	       _IMAGE_COLD_SUB_MODULES_MUST_IN) ||

	      collect_section_type == _IMAGE_CFG_SUB_MODULES_MUST_IN))

		return true;



	if (update_type == FW_UPDATE_HOT &&

	    (collect_section_type & _IMAGE_HOT_SUB_MODULES_MUST_IN) ==

	    _IMAGE_HOT_SUB_MODULES_MUST_IN)

		return true;



	if (update_type == FW_UPDATE_COLD)

		dev_err(&priv->hwdev->hwif->pdev->dev, "Check file integrity failed, valid: 0x%x or 0x%lx, current: 0x%x\n",

			_IMAGE_COLD_SUB_MODULES_MUST_IN,

			_IMAGE_CFG_SUB_MODULES_MUST_IN, collect_section_type);

	else

		dev_err(&priv->hwdev->hwif->pdev->dev, "Check file integrity failed, valid:0x%x, current: 0x%x\n",

			_IMAGE_HOT_SUB_MODULES_MUST_IN, collect_section_type);



	return false;

}



static int check_image_device_type(struct hinic_devlink_priv *priv,

				   u32 image_device_type)

{

	struct hinic_comm_board_info board_info = {0};



	if (hinic_get_board_info(priv->hwdev, &board_info)) {

		dev_err(&priv->hwdev->hwif->pdev->dev, "Get board info failed\n");

		return false;

	}



	if (image_device_type == board_info.info.board_type)

		return true;



	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");

	dev_err(&priv->hwdev->hwif->pdev->dev, "The image device type: 0x%x, firmware device type: 0x%x\n",

		image_device_type, board_info.info.board_type);



	return false;

}



static int hinic_flash_fw(struct hinic_devlink_priv *priv, const u8 *data,

			  struct host_image_st *host_image)

{

	u32 section_remain_send_len, send_fragment_len, send_pos, up_total_len;

	struct hinic_cmd_update_fw *fw_update_msg = NULL;

	u32 section_type, section_crc, section_version;

	u32 i, len, section_len, section_offset;

	u16 out_size = sizeof(*fw_update_msg);

	int total_len_flag = 0;

	int err;



	fw_update_msg = kzalloc(sizeof(*fw_update_msg), GFP_KERNEL);

	if (!fw_update_msg)

		return -ENOMEM;



	up_total_len = host_image->image_info.up_total_len;



	for (i = 0; i < host_image->section_type_num; i++) {

		len = host_image->image_section_info[i].fw_section_len;

		if (host_image->image_section_info[i].fw_section_type ==

		    UP_FW_UPDATE_BOOT) {

			up_total_len = up_total_len - len;

			break;

		}

	}



	for (i = 0; i < host_image->section_type_num; i++) {

		section_len =

			host_image->image_section_info[i].fw_section_len;

		section_offset =

			host_image->image_section_info[i].fw_section_offset;

		section_remain_send_len = section_len;

		section_type =

			host_image->image_section_info[i].fw_section_type;

		section_crc = host_image->image_section_info[i].fw_section_crc;

		section_version =

			host_image->image_section_info[i].fw_section_version;



		if (section_type == UP_FW_UPDATE_BOOT)

			continue;



		send_fragment_len = 0;

		send_pos = 0;



		while (section_remain_send_len > 0) {

			if (!total_len_flag) {

				fw_update_msg->total_len = up_total_len;

				total_len_flag = 1;

			} else {

				fw_update_msg->total_len = 0;

			}



			memset(fw_update_msg->data, 0, MAX_FW_FRAGMENT_LEN);



			fw_update_msg->ctl_info.SF =

				(section_remain_send_len == section_len) ?

				true : false;

			fw_update_msg->section_info.FW_section_CRC = section_crc;

			fw_update_msg->fw_section_version = section_version;

			fw_update_msg->ctl_info.flag = UP_TYPE_A;



			if (section_type <= UP_FW_UPDATE_UP_DATA_B) {

				fw_update_msg->section_info.FW_section_type =

					(section_type % 2) ?

					UP_FW_UPDATE_UP_DATA :

					UP_FW_UPDATE_UP_TEXT;



				fw_update_msg->ctl_info.flag = UP_TYPE_B;

				if (section_type <= UP_FW_UPDATE_UP_DATA_A)

					fw_update_msg->ctl_info.flag = UP_TYPE_A;

			} else {

				fw_update_msg->section_info.FW_section_type =

					section_type - 0x2;

			}



			fw_update_msg->setion_total_len = section_len;

			fw_update_msg->section_offset = send_pos;



			if (section_remain_send_len <= MAX_FW_FRAGMENT_LEN) {

				fw_update_msg->ctl_info.SL = true;

				fw_update_msg->ctl_info.fragment_len =

					section_remain_send_len;

				send_fragment_len += section_remain_send_len;

			} else {

				fw_update_msg->ctl_info.SL = false;

				fw_update_msg->ctl_info.fragment_len =

					MAX_FW_FRAGMENT_LEN;

				send_fragment_len += MAX_FW_FRAGMENT_LEN;

			}



			memcpy(fw_update_msg->data,

			       data + UPDATEFW_IMAGE_HEAD_SIZE +

			       section_offset + send_pos,

			       fw_update_msg->ctl_info.fragment_len);



			err = hinic_port_msg_cmd(priv->hwdev,

						 HINIC_PORT_CMD_UPDATE_FW,

						 fw_update_msg,

						 sizeof(*fw_update_msg),

						 fw_update_msg, &out_size);

			if (err || !out_size || fw_update_msg->status) {

				dev_err(&priv->hwdev->hwif->pdev->dev, "Failed to update firmware, err: %d, status: 0x%x, out size: 0x%x\n",

					err, fw_update_msg->status, out_size);

				err = fw_update_msg->status ?

					fw_update_msg->status : -EIO;

				kfree(fw_update_msg);

				return err;

			}



			send_pos = send_fragment_len;

			section_remain_send_len = section_len -

						  send_fragment_len;

		}

	}



	kfree(fw_update_msg);



	return 0;

}



static int hinic_firmware_update(struct hinic_devlink_priv *priv,

				 const struct firmware *fw,

				 struct netlink_ext_ack *extack)

{

	struct host_image_st host_image;

	int err;



	memset(&host_image, 0, sizeof(struct host_image_st));



	if (!check_image_valid(priv, fw->data, fw->size, &host_image) ||

	    !check_image_integrity(priv, &host_image, FW_UPDATE_COLD) ||

	    !check_image_device_type(priv, host_image.device_id)) {

		NL_SET_ERR_MSG_MOD(extack, "Check image failed");

		return -EINVAL;

	}



	dev_info(&priv->hwdev->hwif->pdev->dev, "Flash firmware begin\n");



	err = hinic_flash_fw(priv, fw->data, &host_image);

	if (err) {

		if (err == HINIC_FW_DISMATCH_ERROR) {

			dev_err(&priv->hwdev->hwif->pdev->dev, "Firmware image doesn't match this card, please use newer image, err: %d\n",

				err);

			NL_SET_ERR_MSG_MOD(extack,

					   "Firmware image doesn't match this card, please use newer image");

		} else {

			dev_err(&priv->hwdev->hwif->pdev->dev, "Send firmware image data failed, err: %d\n",

				err);

			NL_SET_ERR_MSG_MOD(extack, "Send firmware image data failed");

		}



		return err;

	}



	dev_info(&priv->hwdev->hwif->pdev->dev, "Flash firmware end\n");



	return 0;

}



static int hinic_devlink_flash_update(struct devlink *devlink,

				      const char *file_name,

				      const char *component,

				      struct netlink_ext_ack *extack)

{

	struct hinic_devlink_priv *priv = devlink_priv(devlink);

	const struct firmware *fw;

	int err;



	if (component)

		return -EOPNOTSUPP;



	err = request_firmware_direct(&fw, file_name,

				      &priv->hwdev->hwif->pdev->dev);

	if (err)

		return err;



	err = hinic_firmware_update(priv, fw, extack);

	release_firmware(fw);



	return err;

}



static const struct devlink_ops hinic_devlink_ops = {

	.flash_update = hinic_devlink_flash_update,

};



struct devlink *hinic_devlink_alloc(void)

{

	return devlink_alloc(&hinic_devlink_ops, sizeof(struct hinic_dev));

}



void hinic_devlink_free(struct devlink *devlink)

{

	devlink_free(devlink);

}



int hinic_devlink_register(struct devlink *devlink, struct device *dev)

{

	return devlink_register(devlink, dev);

}



void hinic_devlink_unregister(struct devlink *devlink)

{

	devlink_unregister(devlink);

}

drivers/net/ethernet/huawei/hinic/hinic_devlink.h

0 → 100644
+115 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-only */

/* Huawei HiNIC PCI Express Linux driver

 * Copyright(c) 2017 Huawei Technologies Co., Ltd

 */



#ifndef __HINIC_DEVLINK_H__

#define __HINIC_DEVLINK_H__



#include <net/devlink.h>



#define MAX_FW_TYPE_NUM 30

#define HINIC_MAGIC_NUM 0x18221100

#define UPDATEFW_IMAGE_HEAD_SIZE 1024

#define FW_UPDATE_COLD 0

#define FW_UPDATE_HOT  1



#define UP_TYPE_A 0x0

#define UP_TYPE_B 0x1



#define MAX_FW_FRAGMENT_LEN 1536

#define HINIC_FW_DISMATCH_ERROR 10



enum hinic_fw_type {

	UP_FW_UPDATE_UP_TEXT_A = 0x0,

	UP_FW_UPDATE_UP_DATA_A,

	UP_FW_UPDATE_UP_TEXT_B,

	UP_FW_UPDATE_UP_DATA_B,

	UP_FW_UPDATE_UP_DICT,



	UP_FW_UPDATE_HLINK_ONE = 0x5,

	UP_FW_UPDATE_HLINK_TWO,

	UP_FW_UPDATE_HLINK_THR,

	UP_FW_UPDATE_PHY,

	UP_FW_UPDATE_TILE_TEXT,



	UP_FW_UPDATE_TILE_DATA = 0xa,

	UP_FW_UPDATE_TILE_DICT,

	UP_FW_UPDATE_PPE_STATE,

	UP_FW_UPDATE_PPE_BRANCH,

	UP_FW_UPDATE_PPE_EXTACT,



	UP_FW_UPDATE_CLP_LEGACY = 0xf,

	UP_FW_UPDATE_PXE_LEGACY,

	UP_FW_UPDATE_ISCSI_LEGACY,

	UP_FW_UPDATE_CLP_EFI,

	UP_FW_UPDATE_PXE_EFI,



	UP_FW_UPDATE_ISCSI_EFI = 0x14,

	UP_FW_UPDATE_CFG,

	UP_FW_UPDATE_BOOT,

	UP_FW_UPDATE_VPD,

	FILE_TYPE_TOTAL_NUM

};



#define _IMAGE_UP_ALL_IN ((1 << UP_FW_UPDATE_UP_TEXT_A) | \

			  (1 << UP_FW_UPDATE_UP_DATA_A) | \

			  (1 << UP_FW_UPDATE_UP_TEXT_B) | \

			  (1 << UP_FW_UPDATE_UP_DATA_B) | \

			  (1 << UP_FW_UPDATE_UP_DICT) | \

			  (1 << UP_FW_UPDATE_BOOT) | \

			  (1 << UP_FW_UPDATE_HLINK_ONE) | \

			  (1 << UP_FW_UPDATE_HLINK_TWO) | \

			  (1 << UP_FW_UPDATE_HLINK_THR))



#define _IMAGE_UCODE_ALL_IN ((1 << UP_FW_UPDATE_TILE_TEXT) | \

			     (1 << UP_FW_UPDATE_TILE_DICT) | \

			     (1 << UP_FW_UPDATE_PPE_STATE) | \

			     (1 << UP_FW_UPDATE_PPE_BRANCH) | \

			     (1 << UP_FW_UPDATE_PPE_EXTACT))



#define _IMAGE_COLD_SUB_MODULES_MUST_IN (_IMAGE_UP_ALL_IN | _IMAGE_UCODE_ALL_IN)

#define _IMAGE_HOT_SUB_MODULES_MUST_IN (_IMAGE_UP_ALL_IN | _IMAGE_UCODE_ALL_IN)

#define _IMAGE_CFG_SUB_MODULES_MUST_IN BIT(UP_FW_UPDATE_CFG)

#define UP_FW_UPDATE_UP_TEXT  0x0

#define UP_FW_UPDATE_UP_DATA  0x1

#define UP_FW_UPDATE_VPD_B    0x15



struct fw_section_info_st {

	u32 fw_section_len;

	u32 fw_section_offset;

	u32 fw_section_version;

	u32 fw_section_type;

	u32 fw_section_crc;

};



struct fw_image_st {

	u32 fw_version;

	u32 fw_len;

	u32 fw_magic;

	struct {

		u32 fw_section_cnt:16;

		u32 resd:16;

	} fw_info;

	struct fw_section_info_st fw_section_info[MAX_FW_TYPE_NUM];

	u32 device_id;

	u32 res[101];

	void *bin_data;

};



struct host_image_st {

	struct fw_section_info_st image_section_info[MAX_FW_TYPE_NUM];

	struct {

		u32 up_total_len;

		u32 fw_version;

	} image_info;

	u32 section_type_num;

	u32 device_id;

};



struct devlink *hinic_devlink_alloc(void);

void hinic_devlink_free(struct devlink *devlink);

int hinic_devlink_register(struct devlink *devlink, struct device *dev);

void hinic_devlink_unregister(struct devlink *devlink);



#endif /* __HINIC_DEVLINK_H__ */

drivers/net/ethernet/huawei/hinic/hinic_hw_dev.c

+28 −0
Original line number Diff line number Diff line
@@ -897,6 +897,8 @@ void hinic_free_hwdev(struct hinic_hwdev *hwdev) 


	set_resources_state(hwdev, HINIC_RES_CLEAN);



	hinic_vf_func_free(hwdev);



	free_pfhwdev(pfhwdev);



	hinic_aeqs_free(&hwdev->aeqs);
@@ -1047,3 +1049,29 @@ void hinic_hwdev_set_msix_state(struct hinic_hwdev *hwdev, u16 msix_index, 
{

	hinic_set_msix_state(hwdev->hwif, msix_index, flag);

}



int hinic_get_board_info(struct hinic_hwdev *hwdev,

			 struct hinic_comm_board_info *board_info)

{

	u16 out_size = sizeof(*board_info);

	struct hinic_pfhwdev *pfhwdev;

	int err;



	if (!hwdev || !board_info)

		return -EINVAL;



	pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev);



	err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_COMM,

				HINIC_COMM_CMD_GET_BOARD_INFO,

				board_info, sizeof(*board_info),

				board_info, &out_size, HINIC_MGMT_MSG_SYNC);

	if (err || board_info->status || !out_size) {

		dev_err(&hwdev->hwif->pdev->dev,

			"Failed to get board info, err: %d, status: 0x%x, out size: 0x%x\n",

			err, board_info->status, out_size);

		return -EIO;

	}



	return 0;

}