Commit 2ee95ec1 authored by Dong Yibo's avatar Dong Yibo Committed by Jakub Kicinski
Browse files

net: rnpgbe: Add register_netdev 



Complete the network device (netdev) registration flow for Mucse Gbe
Ethernet chips, including:
1. Hardware state initialization:
   - Send powerup notification to firmware (via echo_fw_status)
   - Sync with firmware
   - Reset hardware
2. MAC address handling:
   - Retrieve permanent MAC from firmware (via mucse_mbx_get_macaddr)
   - Fallback to random valid MAC (eth_random_addr) if not valid mac
     from Fw

Signed-off-by: default avatarDong Yibo <dong100@mucse.com>
Reviewed-by: default avatarVadim Fedorenko <vadim.fedorenko@linux.dev>
Link: https://patch.msgid.link/20251101013849.120565-6-dong100@mucse.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent c6d3f019

drivers/net/ethernet/mucse/rnpgbe/rnpgbe.h

+22 −0
Original line number Diff line number Diff line
@@ -26,18 +26,37 @@ struct mucse_mbx_info { 
	u32 fwpf_ctrl_base;

};



/* Enum for firmware notification modes,

 * more modes (e.g., portup, link_report) will be added in future

 **/

enum {

	mucse_fw_powerup,

};



struct mucse_hw {

	void __iomem *hw_addr;

	struct pci_dev *pdev;

	struct mucse_mbx_info mbx;

	int port;

	u8 pfvfnum;

};



struct mucse_stats {

	u64 tx_dropped;

};



struct mucse {

	struct net_device *netdev;

	struct pci_dev *pdev;

	struct mucse_hw hw;

	struct mucse_stats stats;

};



int rnpgbe_get_permanent_mac(struct mucse_hw *hw, u8 *perm_addr);

int rnpgbe_reset_hw(struct mucse_hw *hw);

int rnpgbe_send_notify(struct mucse_hw *hw,

		       bool enable,

		       int mode);

int rnpgbe_init_hw(struct mucse_hw *hw, int board_type);



/* Device IDs */
@@ -46,4 +65,7 @@ int rnpgbe_init_hw(struct mucse_hw *hw, int board_type); 
#define RNPGBE_DEVICE_ID_N500_DUAL_PORT   0x8318

#define RNPGBE_DEVICE_ID_N210             0x8208

#define RNPGBE_DEVICE_ID_N210L            0x820a



#define mucse_hw_wr32(hw, reg, val) \

	writel((val), (hw)->hw_addr + (reg))

#endif /* _RNPGBE_H */

drivers/net/ethernet/mucse/rnpgbe/rnpgbe_chip.c

+73 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright(c) 2020 - 2025 Mucse Corporation. */



#include <linux/pci.h>

#include <linux/errno.h>

#include <linux/etherdevice.h>



#include "rnpgbe.h"

#include "rnpgbe_hw.h"

#include "rnpgbe_mbx.h"

#include "rnpgbe_mbx_fw.h"



/**

 * rnpgbe_get_permanent_mac - Get permanent mac

 * @hw: hw information structure

 * @perm_addr: pointer to store perm_addr

 *

 * rnpgbe_get_permanent_mac tries to get mac from hw

 *

 * Return: 0 on success, negative errno on failure

 **/

int rnpgbe_get_permanent_mac(struct mucse_hw *hw, u8 *perm_addr)

{

	struct device *dev = &hw->pdev->dev;

	int err;



	err = mucse_mbx_get_macaddr(hw, hw->pfvfnum, perm_addr, hw->port);

	if (err) {

		dev_err(dev, "Failed to get MAC from FW %d\n", err);

		return err;

	}



	if (!is_valid_ether_addr(perm_addr)) {

		dev_err(dev, "Failed to get valid MAC from FW\n");

		return -EINVAL;

	}



	return 0;

}



/**

 * rnpgbe_reset_hw - Do a hardware reset

 * @hw: hw information structure

 *

 * rnpgbe_reset_hw calls fw to do a hardware

 * reset, and cleans some regs to default.

 *

 * Return: 0 on success, negative errno on failure

 **/

int rnpgbe_reset_hw(struct mucse_hw *hw)

{

	mucse_hw_wr32(hw, RNPGBE_DMA_AXI_EN, 0);

	return mucse_mbx_reset_hw(hw);

}



/**

 * rnpgbe_send_notify - Echo fw status

 * @hw: hw information structure

 * @enable: true or false status

 * @mode: status mode

 *

 * Return: 0 on success, negative errno on failure

 **/

int rnpgbe_send_notify(struct mucse_hw *hw,

		       bool enable,

		       int mode)

{

	int err;

	/* Keep switch struct to support more modes in the future */

	switch (mode) {

	case mucse_fw_powerup:

		err = mucse_mbx_powerup(hw, enable);

		break;

	default:

		err = -EINVAL;

	}



	return err;

}



/**

 * rnpgbe_init_n500 - Setup n500 hw info
@@ -50,6 +121,8 @@ int rnpgbe_init_hw(struct mucse_hw *hw, int board_type) 
{

	struct mucse_mbx_info *mbx = &hw->mbx;



	hw->port = 0;



	mbx->pf2fw_mbx_ctrl = MUCSE_GBE_PFFW_MBX_CTRL_OFFSET;

	mbx->fwpf_mbx_mask = MUCSE_GBE_FWPF_MBX_MASK_OFFSET;

drivers/net/ethernet/mucse/rnpgbe/rnpgbe_hw.h

+2 −0
Original line number Diff line number Diff line
@@ -11,5 +11,7 @@ 
#define MUCSE_N210_FWPF_CTRL_BASE      0x29400

#define MUCSE_N210_FWPF_SHM_BASE       0x2d900



#define RNPGBE_DMA_AXI_EN              0x0010



#define RNPGBE_MAX_QUEUES 8

#endif /* _RNPGBE_HW_H */

drivers/net/ethernet/mucse/rnpgbe/rnpgbe_main.c

+117 −2
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ 


#include "rnpgbe.h"

#include "rnpgbe_hw.h"

#include "rnpgbe_mbx_fw.h"



static const char rnpgbe_driver_name[] = "rnpgbe";
@@ -24,6 +25,58 @@ static struct pci_device_id rnpgbe_pci_tbl[] = { 
	{0, },

};



/**

 * rnpgbe_open - Called when a network interface is made active

 * @netdev: network interface device structure

 *

 * The open entry point is called when a network interface is made

 * active by the system (IFF_UP).

 *

 * Return: 0

 **/

static int rnpgbe_open(struct net_device *netdev)

{

	return 0;

}



/**

 * rnpgbe_close - Disables a network interface

 * @netdev: network interface device structure

 *

 * The close entry point is called when an interface is de-activated

 * by the OS.

 *

 * Return: 0, this is not allowed to fail

 **/

static int rnpgbe_close(struct net_device *netdev)

{

	return 0;

}



/**

 * rnpgbe_xmit_frame - Send a skb to driver

 * @skb: skb structure to be sent

 * @netdev: network interface device structure

 *

 * Return: NETDEV_TX_OK

 **/

static netdev_tx_t rnpgbe_xmit_frame(struct sk_buff *skb,

				     struct net_device *netdev)

{

	struct mucse *mucse = netdev_priv(netdev);



	dev_kfree_skb_any(skb);

	mucse->stats.tx_dropped++;



	return NETDEV_TX_OK;

}



static const struct net_device_ops rnpgbe_netdev_ops = {

	.ndo_open       = rnpgbe_open,

	.ndo_stop       = rnpgbe_close,

	.ndo_start_xmit = rnpgbe_xmit_frame,

};



/**

 * rnpgbe_add_adapter - Add netdev for this pci_dev

 * @pdev: PCI device information structure
@@ -39,10 +92,11 @@ static int rnpgbe_add_adapter(struct pci_dev *pdev, 
			      int board_type)

{

	struct net_device *netdev;

	u8 perm_addr[ETH_ALEN];

	void __iomem *hw_addr;

	struct mucse *mucse;

	struct mucse_hw *hw;

	int err;

	int err, err_notify;



	netdev = alloc_etherdev_mq(sizeof(struct mucse), RNPGBE_MAX_QUEUES);

	if (!netdev)
@@ -64,14 +118,67 @@ static int rnpgbe_add_adapter(struct pci_dev *pdev, 
	}



	hw->hw_addr = hw_addr;

	hw->pdev = pdev;



	err = rnpgbe_init_hw(hw, board_type);

	if (err) {

		dev_err(&pdev->dev, "Init hw err %d\n", err);

		goto err_free_net;

	}

	/* Step 1: Send power-up notification to firmware (no response expected)

	 * This informs firmware to initialize hardware power state, but

	 * firmware only acknowledges receipt without returning data. Must be

	 * done before synchronization as firmware may be in low-power idle

	 * state initially.

	 */

	err_notify = rnpgbe_send_notify(hw, true, mucse_fw_powerup);

	if (err_notify) {

		dev_warn(&pdev->dev, "Send powerup to hw failed %d\n",

			 err_notify);

		dev_warn(&pdev->dev, "Maybe low performance\n");

	}

	/* Step 2: Synchronize mailbox communication with firmware (requires

	 * response) After power-up, confirm firmware is ready to process

	 * requests with responses. This ensures subsequent request/response

	 * interactions work reliably.

	 */

	err = mucse_mbx_sync_fw(hw);

	if (err) {

		dev_err(&pdev->dev, "Sync fw failed! %d\n", err);

		goto err_powerdown;

	}



	return 0;

	netdev->netdev_ops = &rnpgbe_netdev_ops;

	err = rnpgbe_reset_hw(hw);

	if (err) {

		dev_err(&pdev->dev, "Hw reset failed %d\n", err);

		goto err_powerdown;

	}



	err = rnpgbe_get_permanent_mac(hw, perm_addr);

	if (!err) {

		eth_hw_addr_set(netdev, perm_addr);

	} else if (err == -EINVAL) {

		dev_warn(&pdev->dev, "Using random MAC\n");

		eth_hw_addr_random(netdev);

	} else if (err) {

		dev_err(&pdev->dev, "get perm_addr failed %d\n", err);

		goto err_powerdown;

	}



	err = register_netdev(netdev);

	if (err)

		goto err_powerdown;



	return 0;

err_powerdown:

	/* notify powerdown only powerup ok */

	if (!err_notify) {

		err_notify = rnpgbe_send_notify(hw, false, mucse_fw_powerup);

		if (err_notify)

			dev_warn(&pdev->dev, "Send powerdown to hw failed %d\n",

				 err_notify);

	}

err_free_net:

	free_netdev(netdev);

	return err;
@@ -138,11 +245,17 @@ static int rnpgbe_probe(struct pci_dev *pdev, const struct pci_device_id *id) 
static void rnpgbe_rm_adapter(struct pci_dev *pdev)

{

	struct mucse *mucse = pci_get_drvdata(pdev);

	struct mucse_hw *hw = &mucse->hw;

	struct net_device *netdev;

	int err;



	if (!mucse)

		return;

	netdev = mucse->netdev;

	unregister_netdev(netdev);

	err = rnpgbe_send_notify(hw, false, mucse_fw_powerup);

	if (err)

		dev_warn(&pdev->dev, "Send powerdown to hw failed %d\n", err);

	free_netdev(netdev);

}
@@ -173,6 +286,8 @@ static void rnpgbe_dev_shutdown(struct pci_dev *pdev) 


	rtnl_lock();

	netif_device_detach(netdev);

	if (netif_running(netdev))

		rnpgbe_close(netdev);

	rtnl_unlock();

	pci_disable_device(pdev);

}