ti-am65-cpsw-nuss-$(CONFIG_TI_K3_AM65_CPSW_SWITCHDEV) += am65-cpsw-switchdev.o
 obj-$(CONFIG_TI_K3_AM65_CPTS) += am65-cpts.o
 
-obj-$(CONFIG_TI_ICSSG_PRUETH) += icssg-prueth.o
-icssg-prueth-y := icssg/icssg_prueth.o \
-                 icssg/icssg_common.o \
-                 icssg/icssg_classifier.o \
-                 icssg/icssg_queues.o \
-                 icssg/icssg_config.o \
-                 icssg/icssg_mii_cfg.o \
-                 icssg/icssg_stats.o \
-                 icssg/icssg_ethtool.o \
-                 icssg/icssg_switchdev.o
-obj-$(CONFIG_TI_ICSSG_PRUETH_SR1) += icssg-prueth-sr1.o
-icssg-prueth-sr1-y := icssg/icssg_prueth_sr1.o \
-                     icssg/icssg_common.o \
-                     icssg/icssg_classifier.o \
-                     icssg/icssg_config.o \
-                     icssg/icssg_mii_cfg.o \
-                     icssg/icssg_stats.o \
-                     icssg/icssg_ethtool.o
+obj-$(CONFIG_TI_ICSSG_PRUETH) += icssg-prueth.o icssg.o
+icssg-prueth-y := icssg/icssg_prueth.o icssg/icssg_switchdev.o
+
+obj-$(CONFIG_TI_ICSSG_PRUETH_SR1) += icssg-prueth-sr1.o icssg.o
+icssg-prueth-sr1-y := icssg/icssg_prueth_sr1.o
+
+icssg-y := icssg/icssg_common.o \
+          icssg/icssg_classifier.o \
+          icssg/icssg_queues.o \
+          icssg/icssg_config.o \
+          icssg/icssg_mii_cfg.o \
+          icssg/icssg_stats.o \
+          icssg/icssg_ethtool.o
+
 obj-$(CONFIG_TI_ICSS_IEP) += icssg/icss_iep.o
 
                     mac[2] << 16 | mac[3] << 24));
        regmap_write(miig_rt, offs[slice].mac1, (u32)(mac[4] | mac[5] << 8));
 }
+EXPORT_SYMBOL_GPL(icssg_class_set_mac_addr);
 
 static void icssg_class_ft1_add_mcast(struct regmap *miig_rt, int slice,
                                      int slot, const u8 *addr, const u8 *mask)
        /* clear CFG2 */
        regmap_write(miig_rt, offs[slice].rx_class_cfg2, 0);
 }
+EXPORT_SYMBOL_GPL(icssg_class_disable);
 
 void icssg_class_default(struct regmap *miig_rt, int slice, bool allmulti,
                         bool is_sr1)
        /* clear CFG2 */
        regmap_write(miig_rt, offs[slice].rx_class_cfg2, 0);
 }
+EXPORT_SYMBOL_GPL(icssg_class_default);
 
 void icssg_class_promiscuous_sr1(struct regmap *miig_rt, int slice)
 {
                regmap_write(miig_rt, offset, data);
        }
 }
+EXPORT_SYMBOL_GPL(icssg_class_promiscuous_sr1);
 
 void icssg_class_add_mcast_sr1(struct regmap *miig_rt, int slice,
                               struct net_device *ndev)
                slot++;
        }
 }
+EXPORT_SYMBOL_GPL(icssg_class_add_mcast_sr1);
 
 /* required for SAV check */
 void icssg_ft1_set_mac_addr(struct regmap *miig_rt, int slice, u8 *mac_addr)
        rx_class_ft1_set_da_mask(miig_rt, slice, 0, mask_addr);
        rx_class_ft1_cfg_set_type(miig_rt, slice, 0, FT1_CFG_TYPE_EQ);
 }
+EXPORT_SYMBOL_GPL(icssg_ft1_set_mac_addr);
 
        if (rx_chn->rx_chn)
                k3_udma_glue_release_rx_chn(rx_chn->rx_chn);
 }
+EXPORT_SYMBOL_GPL(prueth_cleanup_rx_chns);
 
 void prueth_cleanup_tx_chns(struct prueth_emac *emac)
 {
                memset(tx_chn, 0, sizeof(*tx_chn));
        }
 }
+EXPORT_SYMBOL_GPL(prueth_cleanup_tx_chns);
 
 void prueth_ndev_del_tx_napi(struct prueth_emac *emac, int num)
 {
                netif_napi_del(&tx_chn->napi_tx);
        }
 }
+EXPORT_SYMBOL_GPL(prueth_ndev_del_tx_napi);
 
 void prueth_xmit_free(struct prueth_tx_chn *tx_chn,
                      struct cppi5_host_desc_t *desc)
 
        k3_cppi_desc_pool_free(tx_chn->desc_pool, first_desc);
 }
+EXPORT_SYMBOL_GPL(prueth_xmit_free);
 
 int emac_tx_complete_packets(struct prueth_emac *emac, int chn,
                             int budget, bool *tdown)
        prueth_ndev_del_tx_napi(emac, i);
        return ret;
 }
+EXPORT_SYMBOL_GPL(prueth_ndev_add_tx_napi);
 
 int prueth_init_tx_chns(struct prueth_emac *emac)
 {
        prueth_cleanup_tx_chns(emac);
        return ret;
 }
+EXPORT_SYMBOL_GPL(prueth_init_tx_chns);
 
 int prueth_init_rx_chns(struct prueth_emac *emac,
                        struct prueth_rx_chn *rx_chn,
        prueth_cleanup_rx_chns(emac, rx_chn, max_rflows);
        return ret;
 }
+EXPORT_SYMBOL_GPL(prueth_init_rx_chns);
 
 int prueth_dma_rx_push(struct prueth_emac *emac,
                       struct sk_buff *skb,
        return k3_udma_glue_push_rx_chn(rx_chn->rx_chn, 0,
                                        desc_rx, desc_dma);
 }
+EXPORT_SYMBOL_GPL(prueth_dma_rx_push);
 
 u64 icssg_ts_to_ns(u32 hi_sw, u32 hi, u32 lo, u32 cycle_time_ns)
 {
 
        return ns;
 }
+EXPORT_SYMBOL_GPL(icssg_ts_to_ns);
 
 void emac_rx_timestamp(struct prueth_emac *emac,
                       struct sk_buff *skb, u32 *psdata)
 }
 
 /**
- * emac_ndo_start_xmit - EMAC Transmit function
+ * icssg_ndo_start_xmit - EMAC Transmit function
  * @skb: SKB pointer
  * @ndev: EMAC network adapter
  *
  *
  * Return: enum netdev_tx
  */
-enum netdev_tx emac_ndo_start_xmit(struct sk_buff *skb, struct net_device *ndev)
+enum netdev_tx icssg_ndo_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 {
        struct cppi5_host_desc_t *first_desc, *next_desc, *cur_desc;
        struct prueth_emac *emac = netdev_priv(ndev);
        netif_tx_stop_queue(netif_txq);
        return NETDEV_TX_BUSY;
 }
+EXPORT_SYMBOL_GPL(icssg_ndo_start_xmit);
 
 static void prueth_tx_cleanup(void *data, dma_addr_t desc_dma)
 {
 
        return IRQ_HANDLED;
 }
+EXPORT_SYMBOL_GPL(prueth_rx_irq);
 
 void prueth_emac_stop(struct prueth_emac *emac)
 {
        rproc_shutdown(prueth->rtu[slice]);
        rproc_shutdown(prueth->pru[slice]);
 }
+EXPORT_SYMBOL_GPL(prueth_emac_stop);
 
 void prueth_cleanup_tx_ts(struct prueth_emac *emac)
 {
                }
        }
 }
+EXPORT_SYMBOL_GPL(prueth_cleanup_tx_ts);
 
-int emac_napi_rx_poll(struct napi_struct *napi_rx, int budget)
+int icssg_napi_rx_poll(struct napi_struct *napi_rx, int budget)
 {
        struct prueth_emac *emac = prueth_napi_to_emac(napi_rx);
        int rx_flow = emac->is_sr1 ?
 
        return num_rx;
 }
+EXPORT_SYMBOL_GPL(icssg_napi_rx_poll);
 
 int prueth_prepare_rx_chan(struct prueth_emac *emac,
                           struct prueth_rx_chn *chn,
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(prueth_prepare_rx_chan);
 
 void prueth_reset_tx_chan(struct prueth_emac *emac, int ch_num,
                          bool free_skb)
                k3_udma_glue_disable_tx_chn(emac->tx_chns[i].tx_chn);
        }
 }
+EXPORT_SYMBOL_GPL(prueth_reset_tx_chan);
 
 void prueth_reset_rx_chan(struct prueth_rx_chn *chn,
                          int num_flows, bool disable)
        if (disable)
                k3_udma_glue_disable_rx_chn(chn->rx_chn);
 }
+EXPORT_SYMBOL_GPL(prueth_reset_rx_chan);
 
-void emac_ndo_tx_timeout(struct net_device *ndev, unsigned int txqueue)
+void icssg_ndo_tx_timeout(struct net_device *ndev, unsigned int txqueue)
 {
        ndev->stats.tx_errors++;
 }
+EXPORT_SYMBOL_GPL(icssg_ndo_tx_timeout);
 
 static int emac_set_ts_config(struct net_device *ndev, struct ifreq *ifr)
 {
                            -EFAULT : 0;
 }
 
-int emac_ndo_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd)
+int icssg_ndo_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd)
 {
        switch (cmd) {
        case SIOCGHWTSTAMP:
 
        return phy_do_ioctl(ndev, ifr, cmd);
 }
+EXPORT_SYMBOL_GPL(icssg_ndo_ioctl);
 
-void emac_ndo_get_stats64(struct net_device *ndev,
-                         struct rtnl_link_stats64 *stats)
+void icssg_ndo_get_stats64(struct net_device *ndev,
+                          struct rtnl_link_stats64 *stats)
 {
        struct prueth_emac *emac = netdev_priv(ndev);
 
        stats->tx_errors  = ndev->stats.tx_errors;
        stats->tx_dropped = ndev->stats.tx_dropped;
 }
+EXPORT_SYMBOL_GPL(icssg_ndo_get_stats64);
 
-int emac_ndo_get_phys_port_name(struct net_device *ndev, char *name,
-                               size_t len)
+int icssg_ndo_get_phys_port_name(struct net_device *ndev, char *name,
+                                size_t len)
 {
        struct prueth_emac *emac = netdev_priv(ndev);
        int ret;
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(icssg_ndo_get_phys_port_name);
 
 /* get emac_port corresponding to eth_node name */
 int prueth_node_port(struct device_node *eth_node)
        else
                return PRUETH_PORT_INVALID;
 }
+EXPORT_SYMBOL_GPL(prueth_node_port);
 
 /* get MAC instance corresponding to eth_node name */
 int prueth_node_mac(struct device_node *eth_node)
        else
                return PRUETH_MAC_INVALID;
 }
+EXPORT_SYMBOL_GPL(prueth_node_mac);
 
 void prueth_netdev_exit(struct prueth *prueth,
                        struct device_node *eth_node)
        free_netdev(emac->ndev);
        prueth->emac[mac] = NULL;
 }
+EXPORT_SYMBOL_GPL(prueth_netdev_exit);
 
 int prueth_get_cores(struct prueth *prueth, int slice, bool is_sr1)
 {
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(prueth_get_cores);
 
 void prueth_put_cores(struct prueth *prueth, int slice)
 {
        if (prueth->pru[slice])
                pru_rproc_put(prueth->pru[slice]);
 }
+EXPORT_SYMBOL_GPL(prueth_put_cores);
 
 #ifdef CONFIG_PM_SLEEP
 static int prueth_suspend(struct device *dev)
 const struct dev_pm_ops prueth_dev_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(prueth_suspend, prueth_resume)
 };
+EXPORT_SYMBOL_GPL(prueth_dev_pm_ops);
+
+MODULE_AUTHOR("Roger Quadros <rogerq@ti.com>");
+MODULE_AUTHOR("Md Danish Anwar <danishanwar@ti.com>");
+MODULE_DESCRIPTION("PRUSS ICSSG Ethernet Driver Common Module");
+MODULE_LICENSE("GPL");
 
 
        icssg_mii_update_ipg(prueth->mii_rt, slice, ipg);
 }
+EXPORT_SYMBOL_GPL(icssg_config_ipg);
 
 static void emac_r30_cmd_init(struct prueth_emac *emac)
 {
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(icssg_config);
 
 /* Bitmask for ICSSG r30 commands */
 static const struct icssg_r30_cmd emac_r32_bitmask[] = {
        {{0xffef0000,  EMAC_NONE, 0xffef0000, EMAC_NONE}}       /* VLAN UNWARE*/
 };
 
-int emac_set_port_state(struct prueth_emac *emac,
-                       enum icssg_port_state_cmd cmd)
+int icssg_set_port_state(struct prueth_emac *emac,
+                        enum icssg_port_state_cmd cmd)
 {
        struct icssg_r30_cmd __iomem *p;
        int ret = -ETIMEDOUT;
 
        return ret;
 }
+EXPORT_SYMBOL_GPL(icssg_set_port_state);
 
 void icssg_config_half_duplex(struct prueth_emac *emac)
 {
        val = get_random_u32();
        writel(val, emac->dram.va + HD_RAND_SEED_OFFSET);
 }
+EXPORT_SYMBOL_GPL(icssg_config_half_duplex);
 
 void icssg_config_set_speed(struct prueth_emac *emac)
 {
 
        writeb(fw_speed, emac->dram.va + PORT_LINK_SPEED_OFFSET);
 }
+EXPORT_SYMBOL_GPL(icssg_config_set_speed);
 
 int icssg_send_fdb_msg(struct prueth_emac *emac, struct mgmt_cmd *cmd,
                       struct mgmt_cmd_rsp *rsp)
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(icssg_send_fdb_msg);
 
 static void icssg_fdb_setup(struct prueth_emac *emac, struct mgmt_cmd *fdb_cmd,
                            const unsigned char *addr, u8 fid, int cmd)
 
        return -EINVAL;
 }
+EXPORT_SYMBOL_GPL(icssg_fdb_add_del);
 
 int icssg_fdb_lookup(struct prueth_emac *emac, const unsigned char *addr,
                     u8 vid)
 
        return 0;
 }
+EXPORT_SYMBOL_GPL(icssg_fdb_lookup);
 
 void icssg_vtbl_modify(struct prueth_emac *emac, u8 vid, u8 port_mask,
                       u8 untag_mask, bool add)
 
        tbl[vid].fid_c1 = fid_c1;
 }
+EXPORT_SYMBOL_GPL(icssg_vtbl_modify);
 
 u16 icssg_get_pvid(struct prueth_emac *emac)
 {
 
        return pvid;
 }
+EXPORT_SYMBOL_GPL(icssg_get_pvid);
 
 void icssg_set_pvid(struct prueth *prueth, u8 vid, u8 port)
 {
        else
                writel(pvid, prueth->shram.va + EMAC_ICSSG_SWITCH_PORT0_DEFAULT_VLAN_OFFSET);
 }
+EXPORT_SYMBOL_GPL(icssg_set_pvid);
 
        .nway_reset = emac_nway_reset,
        .get_rmon_stats = emac_get_rmon_stats,
 };
+EXPORT_SYMBOL_GPL(icssg_ethtool_ops);
 
                                   (mtu - 1) << PRUSS_MII_RT_RX_FRMS_MAX_FRM_SHIFT);
        }
 }
+EXPORT_SYMBOL_GPL(icssg_mii_update_mtu);
 
 void icssg_update_rgmii_cfg(struct regmap *miig_rt, struct prueth_emac *emac)
 {
        regmap_update_bits(miig_rt, RGMII_CFG_OFFSET, full_duplex_mask,
                           full_duplex_val);
 }
+EXPORT_SYMBOL_GPL(icssg_update_rgmii_cfg);
 
 void icssg_miig_set_interface_mode(struct regmap *miig_rt, int mii, phy_interface_t phy_if)
 {
 
        return icssg_rgmii_cfg_get_bitfield(miig_rt, mask, shift);
 }
+EXPORT_SYMBOL_GPL(icssg_rgmii_get_speed);
 
 u32 icssg_rgmii_get_fullduplex(struct regmap *miig_rt, int mii)
 {
 
        return icssg_rgmii_cfg_get_bitfield(miig_rt, mask, shift);
 }
+EXPORT_SYMBOL_GPL(icssg_rgmii_get_fullduplex);
 
                        icssg_config_ipg(emac);
                        spin_unlock_irqrestore(&emac->lock, flags);
                        icssg_config_set_speed(emac);
-                       emac_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
+                       icssg_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
 
                } else {
-                       emac_set_port_state(emac, ICSSG_EMAC_PORT_DISABLE);
+                       icssg_set_port_state(emac, ICSSG_EMAC_PORT_DISABLE);
                }
        }
 
 
        promisc = ndev->flags & IFF_PROMISC;
        allmulti = ndev->flags & IFF_ALLMULTI;
-       emac_set_port_state(emac, ICSSG_EMAC_PORT_UC_FLOODING_DISABLE);
-       emac_set_port_state(emac, ICSSG_EMAC_PORT_MC_FLOODING_DISABLE);
+       icssg_set_port_state(emac, ICSSG_EMAC_PORT_UC_FLOODING_DISABLE);
+       icssg_set_port_state(emac, ICSSG_EMAC_PORT_MC_FLOODING_DISABLE);
 
        if (promisc) {
-               emac_set_port_state(emac, ICSSG_EMAC_PORT_UC_FLOODING_ENABLE);
-               emac_set_port_state(emac, ICSSG_EMAC_PORT_MC_FLOODING_ENABLE);
+               icssg_set_port_state(emac, ICSSG_EMAC_PORT_UC_FLOODING_ENABLE);
+               icssg_set_port_state(emac, ICSSG_EMAC_PORT_MC_FLOODING_ENABLE);
                return;
        }
 
        if (allmulti) {
-               emac_set_port_state(emac, ICSSG_EMAC_PORT_MC_FLOODING_ENABLE);
+               icssg_set_port_state(emac, ICSSG_EMAC_PORT_MC_FLOODING_ENABLE);
                return;
        }
 
 static const struct net_device_ops emac_netdev_ops = {
        .ndo_open = emac_ndo_open,
        .ndo_stop = emac_ndo_stop,
-       .ndo_start_xmit = emac_ndo_start_xmit,
+       .ndo_start_xmit = icssg_ndo_start_xmit,
        .ndo_set_mac_address = eth_mac_addr,
        .ndo_validate_addr = eth_validate_addr,
-       .ndo_tx_timeout = emac_ndo_tx_timeout,
+       .ndo_tx_timeout = icssg_ndo_tx_timeout,
        .ndo_set_rx_mode = emac_ndo_set_rx_mode,
-       .ndo_eth_ioctl = emac_ndo_ioctl,
-       .ndo_get_stats64 = emac_ndo_get_stats64,
-       .ndo_get_phys_port_name = emac_ndo_get_phys_port_name,
+       .ndo_eth_ioctl = icssg_ndo_ioctl,
+       .ndo_get_stats64 = icssg_ndo_get_stats64,
+       .ndo_get_phys_port_name = icssg_ndo_get_phys_port_name,
 };
 
 static int prueth_netdev_init(struct prueth *prueth,
        }
        INIT_WORK(&emac->rx_mode_work, emac_ndo_set_rx_mode_work);
 
-       INIT_DELAYED_WORK(&emac->stats_work, emac_stats_work_handler);
+       INIT_DELAYED_WORK(&emac->stats_work, icssg_stats_work_handler);
 
        ret = pruss_request_mem_region(prueth->pruss,
                                       port == PRUETH_PORT_MII0 ?
        ndev->hw_features = NETIF_F_SG;
        ndev->features = ndev->hw_features;
 
-       netif_napi_add(ndev, &emac->napi_rx, emac_napi_rx_poll);
+       netif_napi_add(ndev, &emac->napi_rx, icssg_napi_rx_poll);
        hrtimer_init(&emac->rx_hrtimer, CLOCK_MONOTONIC,
                     HRTIMER_MODE_REL_PINNED);
        emac->rx_hrtimer.function = &emac_rx_timer_callback;
                netif_device_detach(emac1->ndev);
 
        /* Disable both PRUeth ports */
-       emac_set_port_state(emac0, ICSSG_EMAC_PORT_DISABLE);
-       emac_set_port_state(emac1, ICSSG_EMAC_PORT_DISABLE);
+       icssg_set_port_state(emac0, ICSSG_EMAC_PORT_DISABLE);
+       icssg_set_port_state(emac1, ICSSG_EMAC_PORT_DISABLE);
 
        /* Stop both pru cores for both PRUeth ports*/
        prueth_emac_stop(emac0);
        prueth->emacs_initialized++;
 
        /* Enable forwarding for both PRUeth ports */
-       emac_set_port_state(emac0, ICSSG_EMAC_PORT_FORWARD);
-       emac_set_port_state(emac1, ICSSG_EMAC_PORT_FORWARD);
+       icssg_set_port_state(emac0, ICSSG_EMAC_PORT_FORWARD);
+       icssg_set_port_state(emac1, ICSSG_EMAC_PORT_FORWARD);
 
        /* Attache net_device for both PRUeth ports */
        netif_device_attach(emac0->ndev);
                                          BIT(emac->port_id) | DEFAULT_UNTAG_MASK,
                                          true);
                        icssg_set_pvid(prueth, emac->port_vlan, emac->port_id);
-                       emac_set_port_state(emac, ICSSG_EMAC_PORT_VLAN_AWARE_ENABLE);
+                       icssg_set_port_state(emac, ICSSG_EMAC_PORT_VLAN_AWARE_ENABLE);
                }
        }
 }
 
 void icssg_config_ipg(struct prueth_emac *emac);
 int icssg_config(struct prueth *prueth, struct prueth_emac *emac,
                 int slice);
-int emac_set_port_state(struct prueth_emac *emac,
-                       enum icssg_port_state_cmd state);
+int icssg_set_port_state(struct prueth_emac *emac,
+                        enum icssg_port_state_cmd state);
 void icssg_config_set_speed(struct prueth_emac *emac);
 void icssg_config_half_duplex(struct prueth_emac *emac);
 
 #define prueth_napi_to_tx_chn(pnapi) \
        container_of(pnapi, struct prueth_tx_chn, napi_tx)
 
-void emac_stats_work_handler(struct work_struct *work);
+void icssg_stats_work_handler(struct work_struct *work);
 void emac_update_hardware_stats(struct prueth_emac *emac);
 int emac_get_stat_by_name(struct prueth_emac *emac, char *stat_name);
 
                       struct prueth_rx_chn *rx_chn);
 void emac_rx_timestamp(struct prueth_emac *emac,
                       struct sk_buff *skb, u32 *psdata);
-enum netdev_tx emac_ndo_start_xmit(struct sk_buff *skb, struct net_device *ndev);
+enum netdev_tx icssg_ndo_start_xmit(struct sk_buff *skb, struct net_device *ndev);
 irqreturn_t prueth_rx_irq(int irq, void *dev_id);
 void prueth_emac_stop(struct prueth_emac *emac);
 void prueth_cleanup_tx_ts(struct prueth_emac *emac);
-int emac_napi_rx_poll(struct napi_struct *napi_rx, int budget);
+int icssg_napi_rx_poll(struct napi_struct *napi_rx, int budget);
 int prueth_prepare_rx_chan(struct prueth_emac *emac,
                           struct prueth_rx_chn *chn,
                           int buf_size);
                          bool free_skb);
 void prueth_reset_rx_chan(struct prueth_rx_chn *chn,
                          int num_flows, bool disable);
-void emac_ndo_tx_timeout(struct net_device *ndev, unsigned int txqueue);
-int emac_ndo_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd);
-void emac_ndo_get_stats64(struct net_device *ndev,
-                         struct rtnl_link_stats64 *stats);
-int emac_ndo_get_phys_port_name(struct net_device *ndev, char *name,
-                               size_t len);
+void icssg_ndo_tx_timeout(struct net_device *ndev, unsigned int txqueue);
+int icssg_ndo_ioctl(struct net_device *ndev, struct ifreq *ifr, int cmd);
+void icssg_ndo_get_stats64(struct net_device *ndev,
+                          struct rtnl_link_stats64 *stats);
+int icssg_ndo_get_phys_port_name(struct net_device *ndev, char *name,
+                                size_t len);
 int prueth_node_port(struct device_node *eth_node);
 int prueth_node_mac(struct device_node *eth_node);
 void prueth_netdev_exit(struct prueth *prueth,
 
 static const struct net_device_ops emac_netdev_ops = {
        .ndo_open = emac_ndo_open,
        .ndo_stop = emac_ndo_stop,
-       .ndo_start_xmit = emac_ndo_start_xmit,
+       .ndo_start_xmit = icssg_ndo_start_xmit,
        .ndo_set_mac_address = eth_mac_addr,
        .ndo_validate_addr = eth_validate_addr,
-       .ndo_tx_timeout = emac_ndo_tx_timeout,
+       .ndo_tx_timeout = icssg_ndo_tx_timeout,
        .ndo_set_rx_mode = emac_ndo_set_rx_mode_sr1,
-       .ndo_eth_ioctl = emac_ndo_ioctl,
-       .ndo_get_stats64 = emac_ndo_get_stats64,
-       .ndo_get_phys_port_name = emac_ndo_get_phys_port_name,
+       .ndo_eth_ioctl = icssg_ndo_ioctl,
+       .ndo_get_stats64 = icssg_ndo_get_stats64,
+       .ndo_get_phys_port_name = icssg_ndo_get_phys_port_name,
 };
 
 static int prueth_netdev_init(struct prueth *prueth,
                goto free_ndev;
        }
 
-       INIT_DELAYED_WORK(&emac->stats_work, emac_stats_work_handler);
+       INIT_DELAYED_WORK(&emac->stats_work, icssg_stats_work_handler);
 
        ret = pruss_request_mem_region(prueth->pruss,
                                       port == PRUETH_PORT_MII0 ?
        ndev->hw_features = NETIF_F_SG;
        ndev->features = ndev->hw_features;
 
-       netif_napi_add(ndev, &emac->napi_rx, emac_napi_rx_poll);
+       netif_napi_add(ndev, &emac->napi_rx, icssg_napi_rx_poll);
        prueth->emac[mac] = emac;
 
        return 0;
 
 
        return val;
 }
+EXPORT_SYMBOL_GPL(icssg_queue_pop);
 
 void icssg_queue_push(struct prueth *prueth, int queue, u16 addr)
 {
 
        regmap_write(prueth->miig_rt, ICSSG_QUEUE_OFFSET + 4 * queue, addr);
 }
+EXPORT_SYMBOL_GPL(icssg_queue_push);
 
 u32 icssg_queue_level(struct prueth *prueth, int queue)
 {
 
        }
 }
 
-void emac_stats_work_handler(struct work_struct *work)
+void icssg_stats_work_handler(struct work_struct *work)
 {
        struct prueth_emac *emac = container_of(work, struct prueth_emac,
                                                stats_work.work);
        queue_delayed_work(system_long_wq, &emac->stats_work,
                           msecs_to_jiffies((STATS_TIME_LIMIT_1G_MS * 1000) / emac->speed));
 }
+EXPORT_SYMBOL_GPL(icssg_stats_work_handler);
 
 int emac_get_stat_by_name(struct prueth_emac *emac, char *stat_name)
 {
 
                return -EOPNOTSUPP;
        }
 
-       emac_set_port_state(emac, emac_state);
+       icssg_set_port_state(emac, emac_state);
        netdev_dbg(emac->ndev, "STP state: %u\n", emac_state);
 
        return ret;
        netdev_dbg(emac->ndev, "BR_MCAST_FLOOD: %d port %u\n",
                   emac_state, emac->port_id);
 
-       emac_set_port_state(emac, emac_state);
+       icssg_set_port_state(emac, emac_state);
 
        return 0;
 }