linux-kernel/linux-7.2.3/drivers/net/ethernet/mucse/rnpgbe/rnpgbe_mbx_fw.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2020 - 2025 Mucse Corporation. */

#include <linux/if_ether.h>
#include <linux/bitfield.h>

#include "rnpgbe.h"
#include "rnpgbe_mbx.h"
#include "rnpgbe_mbx_fw.h"

/**
 * mucse_fw_send_cmd_wait_resp - Send cmd req and wait for response
 * @hw: pointer to the HW structure
 * @req: pointer to the cmd req structure
 * @reply: pointer to the fw reply structure
 *
 * mucse_fw_send_cmd_wait_resp sends req to pf-fw mailbox and wait
 * reply from fw.
 *
 * Return: 0 on success, negative errno on failure
 **/
static int mucse_fw_send_cmd_wait_resp(struct mucse_hw *hw,
				       union mbx_fw_cmd_req_u *req,
				       union mbx_fw_cmd_reply_u *reply)
{
	int len = le16_to_cpu(req->r.datalen);
	int retry_cnt = 3;
	int err;

	mutex_lock(&hw->mbx.lock);
	err = mucse_write_and_wait_ack_mbx(hw, req->dwords, len);
	if (err)
		goto out;
	do {
		err = mucse_poll_and_read_mbx(hw, reply->dwords,
					      sizeof(reply->r));
		if (err)
			goto out;
		/* mucse_write_and_wait_ack_mbx return 0 means fw has
		 * received request, wait for the expect opcode
		 * reply with 'retry_cnt' times.
		 */
	} while (--retry_cnt >= 0 && reply->r.opcode != req->r.opcode);
out:
	mutex_unlock(&hw->mbx.lock);
	if (!err && retry_cnt < 0)
		return -ETIMEDOUT;
	if (!err && reply->r.error_code)
		return -EIO;

	return err;
}

/**
 * mucse_mbx_get_info - Get hw info from fw
 * @hw: pointer to the HW structure
 *
 * mucse_mbx_get_info tries to get hw info from hw.
 *
 * Return: 0 on success, negative errno on failure
 **/
static int mucse_mbx_get_info(struct mucse_hw *hw)
{
	union mbx_fw_cmd_req_u req = {
		.r = {
			.datalen = cpu_to_le16(MUCSE_MBX_REQ_HDR_LEN),
			.opcode  = cpu_to_le16(GET_HW_INFO),
		},
	};
	union mbx_fw_cmd_reply_u reply = {};
	int err;

	err = mucse_fw_send_cmd_wait_resp(hw, &req, &reply);
	if (!err)
		hw->pfvfnum = FIELD_GET(GENMASK_U16(7, 0),
					le16_to_cpu(reply.r.hw_info.pfnum));

	return err;
}

/**
 * mucse_mbx_sync_fw - Try to sync with fw
 * @hw: pointer to the HW structure
 *
 * mucse_mbx_sync_fw tries to sync with fw. It is only called in
 * probe. Nothing (register network) todo if failed.
 * Try more times to do sync.
 *
 * Return: 0 on success, negative errno on failure
 **/
int mucse_mbx_sync_fw(struct mucse_hw *hw)
{
	int try_cnt = 3;
	int err;

	do {
		err = mucse_mbx_get_info(hw);
	} while (err == -ETIMEDOUT && try_cnt--);

	return err;
}

/**
 * mucse_mbx_powerup - Echo fw to powerup
 * @hw: pointer to the HW structure
 * @is_powerup: true for powerup, false for powerdown
 *
 * mucse_mbx_powerup echo fw to change working frequency
 * to normal after received true, and reduce working frequency
 * if false.
 *
 * Return: 0 on success, negative errno on failure
 **/
int mucse_mbx_powerup(struct mucse_hw *hw, bool is_powerup)
{
	union mbx_fw_cmd_req_u req = {
		.r = {
			.datalen = cpu_to_le16(sizeof(req.r.powerup) +
					       MUCSE_MBX_REQ_HDR_LEN),
			.opcode  = cpu_to_le16(POWER_UP),
			.powerup = {
				/* fw needs this to reply correct cmd */
				.version = cpu_to_le32(GENMASK_U32(31, 0)),
				.status  = cpu_to_le32(is_powerup ? 1 : 0),
			},
		},
	};
	int len, err;

	len = le16_to_cpu(req.r.datalen);
	mutex_lock(&hw->mbx.lock);
	err = mucse_write_and_wait_ack_mbx(hw, req.dwords, len);
	mutex_unlock(&hw->mbx.lock);

	return err;
}

/**
 * mucse_mbx_reset_hw - Posts a mbx req to reset hw
 * @hw: pointer to the HW structure
 *
 * mucse_mbx_reset_hw posts a mbx req to firmware to reset hw.
 * We use mucse_fw_send_cmd_wait_resp to wait hw reset ok.
 *
 * Return: 0 on success, negative errno on failure
 **/
int mucse_mbx_reset_hw(struct mucse_hw *hw)
{
	union mbx_fw_cmd_req_u req = {
		.r = {
			.datalen = cpu_to_le16(MUCSE_MBX_REQ_HDR_LEN),
			.opcode  = cpu_to_le16(RESET_HW),
		},
	};
	union mbx_fw_cmd_reply_u reply = {};

	return mucse_fw_send_cmd_wait_resp(hw, &req, &reply);
}

/**
 * mucse_mbx_get_macaddr - Posts a mbx req to request macaddr
 * @hw: pointer to the HW structure
 * @pfvfnum: index of pf/vf num
 * @mac_addr: pointer to store mac_addr
 * @port: port index
 *
 * mucse_mbx_get_macaddr posts a mbx req to firmware to get mac_addr.
 *
 * Return: 0 on success, negative errno on failure
 **/
int mucse_mbx_get_macaddr(struct mucse_hw *hw, int pfvfnum,
			  u8 *mac_addr,
			  int port)
{
	union mbx_fw_cmd_req_u req = {
		.r = {
			.datalen      = cpu_to_le16(sizeof(req.r.get_mac_addr) +
						    MUCSE_MBX_REQ_HDR_LEN),
			.opcode       = cpu_to_le16(GET_MAC_ADDRESS),
			.get_mac_addr = {
				.port_mask = cpu_to_le32(BIT(port)),
				.pfvf_num  = cpu_to_le32(pfvfnum),
			},
		},
	};
	union mbx_fw_cmd_reply_u reply = {};
	int err;

	err = mucse_fw_send_cmd_wait_resp(hw, &req, &reply);
	if (err)
		return err;

	if (le32_to_cpu(reply.r.mac_addr.ports) & BIT(port))
		memcpy(mac_addr, reply.r.mac_addr.addrs[port].mac, ETH_ALEN);
	else
		return -ENODATA;

	return 0;
}