On Thu, Aug 24, 2023 at 08:50:11PM +0800, Keguang Zhang wrote:

+#define LS1X_GMAC1_BASE		(0xe20000)

If LS1C doesn't have the second GMAC then what about changing the
macros name to LS1B_GMAC1_BASE?

+
+/* Loongson-1 SYSCON Registers */
+#define LS1X_SYSCON0		(0x0)
+#define LS1X_SYSCON1		(0x4)
+
+/* Loongson-1B SYSCON Register Bits */

+#define GMAC1_USE_UART1		BIT(4)
+#define GMAC1_USE_UART0		BIT(3)
+
+#define GMAC1_SHUT		BIT(13)
+#define GMAC0_SHUT		BIT(12)
+
+#define GMAC1_USE_TXCLK		BIT(3)
+#define GMAC0_USE_TXCLK		BIT(2)
+#define GMAC1_USE_PWM23		BIT(1)
+#define GMAC0_USE_PWM01		BIT(0)
+
+/* Loongson-1C SYSCON Register Bits */
+#define GMAC_SHUT		BIT(6)
+
+#define PHY_INTF_SELI		GENMASK(30, 28)

IMO having the SoC-specific prefixes (LS1B_ and LS1C_) in these names
would make the driver a bit more readable. But it's up to you to
decide.

+#define PHY_INTF_SELI_SHIFT	28

Use FIELD_PREP():
#define PHY_INTF_MII			FIELD_PREP(PHY_INTF_SELI, 0)
#define PHY_INTF_RMII			FIELD_PREP(PHY_INTF_SELI, 4)

+
+struct ls1x_dwmac_syscon {
+	int (*syscon_init)(struct plat_stmmacenet_data *plat);
+};

This struct is redundant. See further for details.

+
+struct ls1x_dwmac {

+	unsigned long reg_base;

this field

+	struct device *dev;

+	struct plat_stmmacenet_data *plat_dat;
+	const struct ls1x_dwmac_syscon *syscon;

and these fields are also redundant. See further for details.

+	struct regmap *regmap;
+};
+
+static int ls1b_dwmac_syscon_init(struct plat_stmmacenet_data *plat)
+{
+	struct ls1x_dwmac *dwmac = plat->bsp_priv;
+	struct regmap *regmap = dwmac->regmap;
+

+	if ((dwmac->reg_base & LS1X_GMAC0_BASE) == LS1X_GMAC0_BASE) {

Is it necessary to bitwise-and-ing? What if LS1X_GMAC0_BASE would be
just a full physical base address? Then you'll be able to just compare
the base addresses.

+		switch (plat->phy_interface) {
+		case PHY_INTERFACE_MODE_RGMII_ID:
+			regmap_update_bits(regmap, LS1X_SYSCON0,
+					   GMAC0_USE_TXCLK | GMAC0_USE_PWM01,
+					   0);
+			break;
+		case PHY_INTERFACE_MODE_MII:
+			regmap_update_bits(regmap, LS1X_SYSCON0,
+					   GMAC0_USE_TXCLK | GMAC0_USE_PWM01,
+					   GMAC0_USE_TXCLK | GMAC0_USE_PWM01);
+			break;
+		default:
+			dev_err(dwmac->dev, "Unsupported PHY mode %u\n",
+				plat->phy_interface);
+			return -EOPNOTSUPP;
+		}
+
+		regmap_update_bits(regmap, LS1X_SYSCON0, GMAC0_SHUT, 0);

+	}
+
+	if ((dwmac->reg_base & LS1X_GMAC1_BASE) == LS1X_GMAC1_BASE) {

else if?

+		regmap_update_bits(regmap, LS1X_SYSCON0,
+				   GMAC1_USE_UART1 | GMAC1_USE_UART0,
+				   GMAC1_USE_UART1 | GMAC1_USE_UART0);
+
+		switch (plat->phy_interface) {
+		case PHY_INTERFACE_MODE_RGMII_ID:
+			regmap_update_bits(regmap, LS1X_SYSCON1,
+					   GMAC1_USE_TXCLK | GMAC1_USE_PWM23,
+					   0);
+
+			break;
+		case PHY_INTERFACE_MODE_MII:
+			regmap_update_bits(regmap, LS1X_SYSCON1,
+					   GMAC1_USE_TXCLK | GMAC1_USE_PWM23,
+					   GMAC1_USE_TXCLK | GMAC1_USE_PWM23);
+			break;
+		default:
+			dev_err(dwmac->dev, "Unsupported PHY mode %u\n",
+				plat->phy_interface);
+			return -EOPNOTSUPP;
+		}
+
+		regmap_update_bits(regmap, LS1X_SYSCON1, GMAC1_SHUT, 0);

+	}

else {
	dev_err(...)
	return -EINVAL;
}
?

* unless you have some more DW GMACs on the SoC which don't require the
syscon setups.

+
+	return 0;
+}
+
+static int ls1c_dwmac_syscon_init(struct plat_stmmacenet_data *plat)
+{
+	struct ls1x_dwmac *dwmac = plat->bsp_priv;
+	struct regmap *regmap = dwmac->regmap;
+
+	switch (plat->phy_interface) {
+	case PHY_INTERFACE_MODE_MII:

+		regmap_update_bits(regmap, LS1X_SYSCON1, PHY_INTF_SELI, 0);

		regmap_update_bits(regmap, LS1X_SYSCON1, PHY_INTF_SELI,
				   PHY_INTF_MII);

+		break;
+	case PHY_INTERFACE_MODE_RMII:

+		regmap_update_bits(regmap, LS1X_SYSCON1, PHY_INTF_SELI,
+				   4 << PHY_INTF_SELI_SHIFT);

		regmap_update_bits(regmap, LS1X_SYSCON1, PHY_INTF_SELI,
				   PHY_INTF_RMII);

+		break;
+	default:
+		dev_err(dwmac->dev, "Unsupported PHY-mode %u\n",
+			plat->phy_interface);
+		return -EOPNOTSUPP;
+	}
+
+	regmap_update_bits(regmap, LS1X_SYSCON0, GMAC0_SHUT, 0);
+
+	return 0;
+}
+

+static const struct ls1x_dwmac_syscon ls1b_dwmac_syscon = {
+	.syscon_init = ls1b_dwmac_syscon_init,
+};
+
+static const struct ls1x_dwmac_syscon ls1c_dwmac_syscon = {
+	.syscon_init = ls1c_dwmac_syscon_init,
+};

This can be dropped. See the next comment for details.

+
+static int ls1x_dwmac_init(struct platform_device *pdev, void *priv)
+{
+	struct ls1x_dwmac *dwmac = priv;
+	struct resource *res;
+	int ret;
+

+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!res) {
+		dev_err(&pdev->dev, "Could not get IO_MEM resources\n");
+		return -EINVAL;
+	}
+	dwmac->reg_base = (unsigned long)res->start;

What about moving this to ls1b_dwmac_syscon_init() seeing it's used
for LS1B only? Thus you won't need to have the reg_base defined in the
private data and can get rid from the ls1x_dwmac_init() method setting
the ls1b_dwmac_syscon_init() and ls1c_dwmac_syscon_init() pointers
directly to the device match data.

+
+	if (dwmac->syscon->syscon_init) {
+		ret = dwmac->syscon->syscon_init(dwmac->plat_dat);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int ls1x_dwmac_probe(struct platform_device *pdev)
+{
+	struct plat_stmmacenet_data *plat_dat;
+	struct stmmac_resources stmmac_res;
+	struct regmap *regmap;
+	struct ls1x_dwmac *dwmac;

+	const struct ls1x_dwmac_syscon *syscon;

This can be replaced with just
int (*init)(struct platform_device *pdev, void *priv);

+	int ret;
+
+	ret = stmmac_get_platform_resources(pdev, &stmmac_res);
+	if (ret)
+		return ret;
+
+	/* Probe syscon */
+	regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
+						 "loongson,ls1-syscon");
+	if (IS_ERR(regmap)) {

+		ret = PTR_ERR(regmap);
+		dev_err(&pdev->dev, "Unable to map syscon: %d\n", ret);
+		return ret;

return dev_err_probe(&pdev->dev, PTR_ERR(regmap), "Unable to find syscon\n");

+	}
+

+	syscon = of_device_get_match_data(&pdev->dev);

init = of_device_get_match_data(&pdev->dev);

+	if (!syscon) {
+		dev_err(&pdev->dev, "No of match data provided\n");
+		return -EINVAL;
+	}
+
+	dwmac = devm_kzalloc(&pdev->dev, sizeof(*dwmac), GFP_KERNEL);
+	if (!dwmac)
+		return -ENOMEM;
+
+	plat_dat = stmmac_probe_config_dt(pdev, stmmac_res.mac);
+	if (IS_ERR(plat_dat)) {
+		dev_err(&pdev->dev, "dt configuration failed\n");
+		return PTR_ERR(plat_dat);
+	}
+
+	plat_dat->bsp_priv = dwmac;

+	plat_dat->init = ls1x_dwmac_init;

plat_dat->init = init;

+	dwmac->dev = &pdev->dev;
+	dwmac->plat_dat = plat_dat;
+	dwmac->syscon = syscon;
+	dwmac->regmap = regmap;
+
+	ret = stmmac_pltfr_probe(pdev, plat_dat, &stmmac_res);
+	if (ret)
+		goto err_remove_config_dt;
+
+	return 0;
+
+err_remove_config_dt:
+	stmmac_remove_config_dt(pdev, plat_dat);
+
+	return ret;
+}
+
+static const struct of_device_id ls1x_dwmac_match[] = {

+	{ .compatible = "loongson,ls1b-gmac", .data = &ls1b_dwmac_syscon, },
+	{ .compatible = "loongson,ls1c-emac", .data = &ls1c_dwmac_syscon, },

{ .compatible = "loongson,ls1b-gmac", .data = &ls1b_dwmac_syscon_init, },
{ .compatible = "loongson,ls1c-emac", .data = &ls1c_dwmac_syscon_init, },

Thus you can simplify the driver by:
1. dropping ls1x_dwmac_syscon definition and its instances.
2. dropping three redundant fields from the ls1x_dwmac structure.
3. dropping the ls1x_dwmac_init() method.
Sounds like worth it.)

Note if no further driver update is planned then you can drop the
ls1x_dwmac->dev field too. Otherwise you can keep it seeing some of
the plat_stmmacenet_data data callbacks do have any device instance
passed.

-Serge(y)

+	{ }
+};
+MODULE_DEVICE_TABLE(of, ls1x_dwmac_match);
+
+static struct platform_driver ls1x_dwmac_driver = {
+	.probe = ls1x_dwmac_probe,
+	.remove_new = stmmac_pltfr_remove,
+	.driver = {
+		.name = "loongson1-dwmac",
+		.of_match_table = ls1x_dwmac_match,
+	},
+};
+module_platform_driver(ls1x_dwmac_driver);
+
+MODULE_AUTHOR("Keguang Zhang [off-list ref]");
+MODULE_DESCRIPTION("Loongson1 DWMAC glue layer");
+MODULE_LICENSE("GPL");
-- 
2.39.2