SFP driver to perform EEPROM dump on AXI memory interface (#231)

NET:ETH:PHY: enabling SFP eeprom dump from AXI memory interface


---------

Co-authored-by: Narayan, Preetam <[email protected]>

Author: preetam-narayan

arch/arm64/boot/dts/intel/socfpga_agilex5_eth_1p10g.dtsi

@@ -60,13 +60,6 @@
                          reg-names = "ptp_bridge";
                 };
 
-                qsfp_eth0: qsfp-eth0 {
-                        compatible = "intel,qsfp-mem";
-                        reg-names = "qsfp-mem-ctrl";
-                        reg = <0x44040000 0x00001000>;
-                        status = "okay";
-                };
-
                 sfp_eth0: sfp-eth0 {
                         compatible = "altera,sfp-mem";
                         reg-names = "sfp-mem-ctrl";
@@ -89,9 +82,6 @@
 			interrupt-names = "dma0_tx_irq", "dma0_rx_irq";
 			interrupts = <GIC_SPI 19 IRQ_TYPE_LEVEL_HIGH>, <GIC_SPI 20 IRQ_TYPE_LEVEL_HIGH>;
 			status = "okay";
-			qsfp-lane = <0x0>;
-			sfp-lane = <0x0>;
-			qsfp = <&qsfp_eth0>;
 			sfp = <&sfp_eth0>;
 			fec-type="no-fec";
 			phy-mode = "10gbase-r";

drivers/net/ethernet/altera/intel_fpga_gts_ethtool.c

@@ -17,6 +17,7 @@
 #include <linux/netdevice.h>
 #include <linux/phy.h>
 #include <linux/sfp.h>
+#include <linux/phy/sfp-mem.h>
 #include <linux/phylink.h>
 #include "altera_eth_dma.h"
 #include "intel_fpga_eth_main.h"
@@ -94,10 +95,16 @@ static void gts_gstrings(struct net_device *dev, u32 stringset, u8 *buf)
 	memcpy(buf, stat_gstrings, GTS_STATS_LEN * ETH_GSTRING_LEN);
 }
 
+static int gts_get_eeprom_len(struct net_device *dev)
+{
+	return A0_EEPROM_SIZE;
+}
+
 static int gts_get_module_info (struct net_device *dev,
 				struct ethtool_modinfo *info)
 {
 	intel_fpga_xtile_eth_private *priv = netdev_priv(dev);
+
 	if (!priv)
 		return -ENODEV;
 
@@ -112,6 +119,7 @@ static int gts_get_module_eeprom(struct net_device *dev,
 				 struct ethtool_eeprom *eeprom, u8 *data)
 {
 	intel_fpga_xtile_eth_private *priv = netdev_priv(dev);
+
 	if (!priv)
 		return -ENODEV;
 
@@ -122,6 +130,21 @@ static int gts_get_module_eeprom(struct net_device *dev,
 	return sfp_get_module_eeprom(priv->dev->sfp_bus, eeprom, data);
 }
 
+static int gts_get_module_eeprom_by_page(struct net_device *dev,
+                                         const struct ethtool_module_eeprom *page,
+                                         struct netlink_ext_ack *extack)
+{
+        intel_fpga_xtile_eth_private *priv = netdev_priv(dev);
+
+	if (!priv)
+                return -ENODEV;
+
+        if (!priv->phylink || !priv->dev || !priv->dev->sfp_bus) {
+                return -ENODEV;
+        }
+    	return sfp_get_module_eeprom_by_page(priv->dev->sfp_bus, page, extack);
+}
+
 static void gts_fill_stats(struct net_device *dev,
 			   struct ethtool_stats *dummy,
 			   u64 *buf)
@@ -1690,7 +1713,10 @@ static const struct ethtool_ops gts_ethtool_ops = {
 	.get_link_ksettings = gts_get_link_ksettings,
 	.set_link_ksettings = gts_set_link_ksettings,
 	.get_module_info = gts_get_module_info,
+	.get_eeprom = gts_get_module_eeprom,
+	.get_eeprom_len = gts_get_eeprom_len,
 	.get_module_eeprom = gts_get_module_eeprom,
+	.get_module_eeprom_by_page = gts_get_module_eeprom_by_page,
 
 };
 

drivers/net/phy/sfp-mem-core.c

@@ -15,6 +15,8 @@
 #include <linux/regmap.h>
 #include <linux/uaccess.h>
 #include <linux/phy/sfp-mem.h>
+#include <linux/sfp.h>
+#include <linux/ethtool.h>
 
 #define CONF_OFF	0x20
 #define CONF_RST_CON	BIT(1)
@@ -87,8 +89,8 @@
 #define MULTI_PAGE_SEL   0x40
 #define A0_END_ADDR     0x880
 
-#define MODE_SEL	BIT(11)
-#define PAGE_SEL	BIT(1)
+#define MODE_SEL	BIT(2)
+#define PAGE_SEL	BIT(11)
 #define A2_START_ADDR	0x100
 #define A2_END_ADDR	0x700
 
@@ -306,15 +308,6 @@ static void sfp_check_hotplug(struct work_struct *work)
         schedule_delayed_work(&sfp->dwork, msecs_to_jiffies(SFP_CHECK_TIME));
 }
 
-int sfp_init_work(struct sfp *sfp)
-{
-	sfp->init = SFP_INIT_RESET;
-
-	INIT_DELAYED_WORK(&sfp->dwork, sfp_check_hotplug);
-	schedule_delayed_work(&sfp->dwork, msecs_to_jiffies(SFP_CHECK_TIME));
-	return 0;
-}
-EXPORT_SYMBOL_GPL(sfp_init_work);
 
 int sfp_register_regmap(struct sfp *sfp)
 {
@@ -333,4 +326,140 @@ void sfp_remove_device(struct sfp *sfp)
 	cancel_delayed_work_sync(&sfp->dwork);
 }
 EXPORT_SYMBOL_GPL(sfp_remove_device);
+
+/* copy the A0, A2 page content */
+static void sfp_page_copy(struct sfp *sfp)
+{
+	u32 *page;
+
+	page = (u32*)sfp->a0_page.a0_page;
+	for(u16 update_eeprom = 0, pg_byte = 0;
+	    update_eeprom < sizeof(sfp->a0_page); pg_byte += 1, update_eeprom += 4)
+		page[pg_byte] =
+			readl(sfp->base + A0_START_ADDR + update_eeprom); 
+
+	page = (u32*)sfp->a2_page.a2_page;
+	for(u16 update_eeprom = 0, pg_byte = 0;
+	    update_eeprom < sizeof(sfp->a2_page); pg_byte += 1, update_eeprom += 4)
+		page[pg_byte] =
+			readl(sfp->base + A2_START_ADDR + update_eeprom); 
+}
+
+static int sfp_module_info(struct sfp *sfp, struct ethtool_modinfo *modinfo)
+{
+	/* Atleast A0 page update is completed */
+	if (!(sfp->init >= SFP_A0PAGE_UPDATE_COMPLETE))
+		return -EIO;
+
+	sfp_page_copy(sfp);
+
+	if ((sfp->a0_page.a0.ext.sff8472_compliance) &&
+            (!((sfp->a0_page.a0.ext.diagmon) & SFP_DIAGMON_ADDRMODE))) {
+                modinfo->type = ETH_MODULE_SFF_8472;
+                //modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
+		modinfo->eeprom_len = A0_EEPROM_SIZE + A2_EEPROM_SIZE;
+        } else {
+                modinfo->type = ETH_MODULE_SFF_8079;
+                modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
+        }
+
+        return 0;
+}
+
+static int sfp_module_eeprom_calc(struct sfp *sfp,
+			     	  u16 offset,
+				  u16 len_dump,
+			     	  u8 *data)
+{
+	u16 from_offset = offset;
+	u16 til_offset  = offset + len_dump;
+
+	if ( (len_dump == 0) || (til_offset > sizeof(sfp->a0_page) + sizeof(sfp->a2_page)) )
+		 return -EINVAL;
+
+	/* offset is within A0 page size */
+	if (til_offset <= ETH_MODULE_SFF_8079_LEN) {
+		/* copy from the offset the desired length */
+		memcpy(data, (u8*)sfp->a0_page.a0_page + from_offset, len_dump);
+	}
+
+	/* offset requested is on A2 page range */
+	else if ((from_offset >= ETH_MODULE_SFF_8079_LEN) && (til_offset <= A2_EEPROM_SIZE)) {
+		memcpy(data,
+		       (u8*)sfp->a2_page.a2_page + from_offset,
+		       len_dump);
+	}
+	else {
+		/* requested dump covers both A0 and A2 */
+		u16 len;
+		
+		len = ETH_MODULE_SFF_8079_LEN - from_offset;
+		memcpy (data, 
+			(u8*)sfp->a0_page.a0_page + from_offset,
+			len);
+
+		memcpy(data + len + 1, (u8*)sfp->a2_page.a2_page, len_dump - len);
+	}
+
+	return 0;	
+}
+		
+static int sfp_module_eeprom(struct sfp *sfp,
+			     struct ethtool_eeprom *ee,
+			     u8 *data)
+{
+	sfp_page_copy(sfp);
+
+	return sfp_module_eeprom_calc(sfp, ee->offset, ee->len, data);
+}
+
+static int sfp_module_eeprom_by_page(struct sfp *sfp,
+                             	     const struct ethtool_module_eeprom *page_data,
+                             	     struct netlink_ext_ack *extack)
+{
+	int ret = 0;
+	u16 abs_offset;
+	
+	if ((page_data->page == 0) && (page_data->length == 1))
+		return 0;
+	
+	abs_offset = (page_data->page * ETH_MODULE_EEPROM_PAGE_LEN) + page_data->offset;
+	
+	if (abs_offset > ETH_MODULE_EEPROM_PAGE_LEN)
+		return -EINVAL;
+
+	ret = sfp_module_eeprom_calc(sfp, page_data->offset,
+				      page_data->length, page_data->data);
+
+	return ret;
+}
+
+static void unused_func(struct sfp *sfp)
+{
+	return;
+}
+
+static const struct sfp_socket_ops sfp_module_ops = {
+	.start = unused_func,
+	.stop =  unused_func,
+	.attach =  unused_func,
+        .module_info = sfp_module_info,
+        .module_eeprom = sfp_module_eeprom,
+	.module_eeprom_by_page = sfp_module_eeprom_by_page,
+};
+
+int sfp_init_work(struct sfp *sfp)
+{
+	sfp->init = SFP_INIT_RESET;
+
+	sfp->sfp_bus = sfp_register_socket(sfp->dev, sfp, &sfp_module_ops);
+	if (!sfp->sfp_bus)
+		return -ENOMEM;
+
+	INIT_DELAYED_WORK(&sfp->dwork, sfp_check_hotplug);
+	schedule_delayed_work(&sfp->dwork, msecs_to_jiffies(SFP_CHECK_TIME));
+	return 0;
+}
+EXPORT_SYMBOL_GPL(sfp_init_work);
+
 MODULE_LICENSE("GPL");

include/linux/phy/sfp-mem.h

@@ -17,6 +17,14 @@
 #include <linux/netdevice.h>
 #include <linux/regmap.h>
 #include <linux/uaccess.h>
+#include <linux/sfp.h>
+
+#define IP_IRRESPONSIVE		 0
+#define IP_RESPONSE_TOLERANCE_LIMIT  100
+
+#define A0_EEPROM_SIZE (ETH_MODULE_SFF_8472_LEN/2)
+#define IMPLEMENTED_A2PAGES 4 /* changing this macro enables to dump A2 multiple pages */
+#define A2_EEPROM_SIZE (ETH_MODULE_SFF_8472_LEN/2) * IMPLEMENTED_A2PAGES
 
 enum sfp_init_status {
 	SFP_INIT_RESET = 0,
@@ -29,6 +37,15 @@ enum sfp_init_status {
 	SFP_A2_UPDATE_ERROR,
 };
 
+union sfp_a2_page {
+	u8 a2_page[A2_EEPROM_SIZE];
+};
+
+union sfp_a0_page {
+	u8 a0_page[A0_EEPROM_SIZE];
+	struct sfp_eeprom_id a0;
+};
+
 /**
  * struct sfp - device private data structure
  * @base: base address of the device.
@@ -46,6 +63,9 @@ struct sfp {
 	enum sfp_init_status init;
 	struct mutex lock;
 	u32 tolerance_count;
+	struct sfp_bus *sfp_bus;
+	union  sfp_a0_page   a0_page;
+	union  sfp_a2_page   a2_page;
 };
 
 int sfp_init_work(struct sfp *qsfp);
@@ -54,7 +74,21 @@ void sfp_remove_device(struct sfp *qsfp);
 bool check_sfp_plugin(struct sfp *qsfp);
 extern const struct attribute_group *sfp_mem_groups[];
 
-#define IP_IRRESPONSIVE		 0
-#define IP_RESPONSE_TOLERANCE_LIMIT  100
+struct sfp_socket_ops {
+        void (*attach)(struct sfp *sfp);
+        void (*detach)(struct sfp *sfp);
+        void (*start)(struct sfp *sfp);
+        void (*stop)(struct sfp *sfp);
+        void (*set_signal_rate)(struct sfp *sfp, unsigned int rate_kbd);
+        int (*module_info)(struct sfp *sfp, struct ethtool_modinfo *modinfo);
+        int (*module_eeprom)(struct sfp *sfp, struct ethtool_eeprom *ee,
+                             u8 *data);
+        int (*module_eeprom_by_page)(struct sfp *sfp,
+                                     const struct ethtool_module_eeprom *page,
+                                     struct netlink_ext_ack *extack);
+};
+
+struct sfp_bus *sfp_register_socket(struct device *dev, struct sfp *sfp,
+                                    const struct sfp_socket_ops *ops);
 
 #endif //__LINUX_SFP_MEM_H