rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/kernel-5.10/drivers/sprd_pcie/sipa/sipa_eth.c

1074 lines
26 KiB
C
Executable File
Raw Blame History

/*
* Copyright (C) 2019 Spreadtrum Communications Inc.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#define pr_fmt(fmt) "sipa_eth: " fmt
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/udp.h>
#include <linux/if_arp.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/of_device.h>
#include <linux/interrupt.h>
#include <linux/netdev_features.h>
#include <linux/mutex.h>
#include <linux/version.h>
#include <linux/debugfs.h>
#include "sipa_eth.h"
#include "../include/sipa.h"
#ifndef ARPHRD_RAWIP
#define ARPHRD_RAWIP ARPHRD_NONE
#endif
//#ifdef CONFIG_PINCTRL_IPQ807x || defined(CONFIG_PINCTRL_IPQ5018)
//#define CONFIG_QCA_NSS_DRV
//#endif
#ifdef CONFIG_QCA_NSS_DRV
#define _RMNET_NSS_H_
#define _RMENT_NSS_H_
struct rmnet_nss_cb {
int (*nss_create)(struct net_device *dev);
int (*nss_free)(struct net_device *dev);
int (*nss_tx)(struct sk_buff *skb);
};
extern struct rmnet_nss_cb *rmnet_nss_callbacks __rcu __read_mostly;
//static struct rmnet_nss_cb __read_mostly *nss_cb = NULL;
#endif
/* Device status */
#define DEV_ON 1
#define DEV_OFF 0
#define SIPA_ETH_NAPI_WEIGHT 64
#define SIPA_ETH_IFACE_PREF "seth"
#define SIPA_ETH_VPCIE_PREF "pcie"
#define SIPA_ETH_VPCIE_IDX 8
#define SIPA_DUMMY_IFACE_NUM 4
static struct dentry *root;
static int sipa_eth_debugfs_mknod(void *root, void *data);
static void sipa_eth_poll_rx_handler (void *priv);
static u64 gro_enable;
struct sipa_eth_netid_device * dev_list[SIPA_DUMMY_IFACE_NUM];
static const unsigned char dhcp_dst_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
//static const u8 default_modem_addr[ETH_ALEN] = {0x02, 0x50, 0xf3};
//static const u8 default_dev_addr[ETH_ALEN] = {0x02, 0x50, 0xf4};
static inline void sipa_eth_dt_stats_init(struct sipa_eth_dtrans_stats *stats)
{
memset(stats, 0, sizeof(*stats));
}
static inline void sipa_eth_rx_stats_update(
struct sipa_eth_dtrans_stats *stats, u32 len)
{
stats->rx_sum += len;
stats->rx_cnt++;
}
static inline void sipa_eth_tx_stats_update(
struct sipa_eth_dtrans_stats *stats, u32 len)
{
stats->tx_sum += len;
stats->tx_cnt++;
}
static void sipa_eth_prepare_skb(struct SIPA_ETH *sipa_eth, struct sk_buff *skb)
{
struct iphdr *iph;
struct ipv6hdr *ipv6h;
struct net_device *dev;
unsigned int real_len = 0, payload_len = 0;
bool ip_arp = true;
dev = sipa_eth->netdev;
skb->protocol = eth_type_trans(skb, dev);
skb_reset_network_header(skb);
switch (ntohs(skb->protocol)) {
case ETH_P_IP:
iph = ip_hdr(skb);
real_len = ntohs(iph->tot_len);
break;
case ETH_P_IPV6:
ipv6h = ipv6_hdr(skb);
payload_len = ntohs(ipv6h->payload_len);
real_len = payload_len + sizeof(struct ipv6hdr);
break;
case ETH_P_ARP:
real_len = arp_hdr_len(dev);
break;
default:
ip_arp = false;
break;
}
if (ip_arp)
skb_trim(skb, real_len);
/* TODO chechsum ... */
skb->ip_summed = CHECKSUM_NONE;
skb->dev = dev;
}
static int sipa_eth_rx(struct SIPA_ETH *sipa_eth, int budget)
{
struct sk_buff *skb;
struct net_device *dev;
struct sipa_eth_dtrans_stats *dt_stats;
int netid;
int skb_cnt = 0;
int ret;
dt_stats = &sipa_eth->dt_stats;
if (!sipa_eth) {
pr_err("no sipa_eth device\n");
return -EINVAL;
}
dev = sipa_eth->netdev;
atomic_set(&sipa_eth->rx_evt, 0);
while (skb_cnt < budget) {
ret = sipa_nic_rx(&netid, &skb, skb_cnt);
if (ret) {
switch (ret) {
case -ENODEV:
pr_err("fail to find dev");
sipa_eth->stats.rx_errors++;
dt_stats->rx_fail++;
dev->stats.rx_errors++;
break;
case -ENODATA:
atomic_set(&sipa_eth->rx_busy, 0);
break;
}
break;
}
if (!skb) {
pr_err("recv skb is null\n");
return -EINVAL;
}
sipa_eth_prepare_skb(sipa_eth, skb);
sipa_eth->stats.rx_packets++;
sipa_eth->stats.rx_bytes += skb->len;
sipa_eth_rx_stats_update(dt_stats, skb->len);
napi_gro_receive(&sipa_eth->napi, skb);
//netif_receive_skb(skb);
skb_cnt++;
}
return skb_cnt;
}
static int sipa_eth_rx_poll_handler(struct napi_struct *napi, int budget)
{
struct SIPA_ETH *sipa_eth = container_of(napi, struct SIPA_ETH, napi);
int tmp = 0, pkts;
/* If the number of pkt is more than weight(64),
* we cannot read them all with a single poll.
* When the return value of poll func equals to weight(64),
* napi structure invokes the poll func one more time by
* __raise_softirq_irqoff.(See napi_poll for details)
* So do not do napi_complete in that case.
*/
READ_AGAIN:
/* For example:
* pkts = 60, tmp = 60, budget = 4
* if rx_evt is true, we goto READ_AGAIN,
* pkts = 4, tmp = 64, budget = 0,
* then we goto out, return 64 to napi,
* In that case, we force napi to do polling again.
*/
pkts = sipa_eth_rx(sipa_eth, budget);
tmp += pkts;
budget -= pkts;
/*
* If budget is 0 here, means we has not finished reading yet,
* so we should return a weight-number(64) to napi to ask it
* do another polling.
*/
if (!budget)
goto out;
/* Due to a cuncurrency issue, we have to do napi_complete
* cautiously. If a socket is in the process of napi polling,
* a SIPA_RECEIVE is arriving to trigger another socket to do receiving,
* we must record it because it will be blocked by rx_busy
* at the first beginning.
* Since this SIPA_RECEIVE notification is a one-shot behaviour
* in sipa_nic. if we chose to ignore this event, we may lose
* the chance to receive forever.
*/
if (atomic_read(&sipa_eth->rx_evt))
goto READ_AGAIN;
/* If the number of budget is more than 0, it means the pkts
* we received is smaller than napi weight(64).
* Then we are okay to do napi_complete.
*/
if (budget) {
napi_complete(napi);
/* Test in a lab, ten threads of TCP streams,
* TPUT reaches to 1Gbps, another edge case occurs,
* rx_busy might be 0, and rx_evt might be 1,
* after we do napi_complete.
* So do rx_handler manually to prevent
* sipa_eth from stopping receiving pkts.
*/
if (atomic_read(&sipa_eth->rx_evt) ||
atomic_read(&sipa_eth->rx_busy)) {
pr_debug("rx evt recv after napi complete");
atomic_set(&sipa_eth->rx_evt, 0);
napi_schedule(&sipa_eth->napi);
}
}
out:
return tmp;
}
/* Attention, The whole RX is deprecated, we use sipa_dummy to rx. */
static void sipa_eth_poll_rx_handler (void *priv)
{
struct SIPA_ETH *sipa_eth = (struct SIPA_ETH *)priv;
if (!sipa_eth) {
pr_err("data is NULL\n");
return;
}
if (!atomic_cmpxchg(&sipa_eth->rx_busy, 0, 1)) {
atomic_set(&sipa_eth->rx_evt, 0);
napi_schedule(&sipa_eth->napi);
/* Trigger a NET_RX_SOFTIRQ softirq directly,
* or there will be a delay
*/
//raise_softirq(NET_RX_SOFTIRQ);
}
}
static void sipa_eth_flowctrl_handler(void *priv, int flowctrl)
{
struct SIPA_ETH *sipa_eth = (struct SIPA_ETH *)priv;
struct net_device *dev = sipa_eth->netdev;
if (flowctrl) {
netif_stop_queue(dev);
} else if (netif_queue_stopped(dev)) {
netif_wake_queue(dev);
}
}
static void sipa_eth_notify_cb(void *priv, enum sipa_evt_type evt,
unsigned int data)
{
struct SIPA_ETH *sipa_eth = (struct SIPA_ETH *)priv;
switch (evt) {
case SIPA_RECEIVE:
atomic_set(&sipa_eth->rx_evt, 1);
sipa_eth_poll_rx_handler(priv);
break;
case SIPA_LEAVE_FLOWCTRL:
pr_info("SIPA LEAVE FLOWCTRL\n");
sipa_eth_flowctrl_handler(priv, 0);
break;
case SIPA_ENTER_FLOWCTRL:
pr_info("SIPA ENTER FLOWCTRL\n");
sipa_eth_flowctrl_handler(priv, 1);
break;
default:
break;
}
}
static int sipa_eth_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct SIPA_ETH *sipa_eth = netdev_priv(dev);
struct sipa_eth_init_data *pdata = sipa_eth->pdata;
struct sipa_eth_dtrans_stats *dt_stats;
int ret = 0, dhcp = 0;
int netid;
dt_stats = &sipa_eth->dt_stats;
if (sipa_eth->state != DEV_ON) {
pr_err("called when %s is down\n", dev->name);
dt_stats->tx_fail++;
netif_carrier_off(dev);
dev_kfree_skb_any(skb);
return NETDEV_TX_OK;
}
netid = pdata->netid;
if (dev->type != ARPHRD_ETHER) {
switch (skb->data[0] & 0xf0) {
case 0x40:
{
struct iphdr *ip4h = (struct iphdr *)(&skb->data[0]);
if (ip4h->protocol == IPPROTO_UDP && ip4h->saddr == 0x00000000 && ip4h->daddr == 0xFFFFFFFF) {
dhcp = 1;
}
skb->protocol = htons(ETH_P_IP);
}
break;
case 0x60:
skb->protocol = htons(ETH_P_IPV6);
break;
default:
if(skb->protocol != htons(ETH_P_ARP)) {
pr_err("unknow skb->protocol %02x\n", skb->data[0]);
goto err;
}
skb->protocol = htons(ETH_P_ARP);
arp_hdr(skb)->ar_hrd = htons(ARPHRD_ETHER);
break;
}
skb_push(skb, ETH_HLEN);
skb_reset_mac_header(skb);
memcpy(eth_hdr(skb)->h_source, dev->dev_addr, ETH_ALEN);
if(dhcp)
memcpy(eth_hdr(skb)->h_dest, dhcp_dst_addr, ETH_ALEN);
else
memcpy(eth_hdr(skb)->h_dest, pdata->modem_mac, ETH_ALEN);
eth_hdr(skb)->h_proto = skb->protocol;
}
ret = sipa_nic_tx(sipa_eth->nic_id, pdata->term_type, netid, skb);
if (unlikely(ret != 0)) {
if (ret == -EAGAIN) {
/*
* resume skb, otherwise
* we may pull this skb ETH_HLEN-bytes twice
*/
if (!pdata->mac_h)
skb_push(skb, ETH_HLEN);
if (dev->type != ARPHRD_ETHER) {
skb_pull_inline(skb, ETH_HLEN);
}
dt_stats->tx_fail++;
sipa_eth->stats.tx_errors++;
/*
if (ret == -EAGAIN) {
netif_stop_queue(dev);
sipa_nic_trigger_flow_ctrl_work(sipa_eth->nic_id, ret);
}
*/
return NETDEV_TX_BUSY;
}
pr_err("fail to send skb, dev 0x%p eth 0x%p nic_id %d, ret %d\n",
dev, sipa_eth, sipa_eth->nic_id, ret);
goto err;
}
/* update netdev statistics */
sipa_eth->stats.tx_packets++;
sipa_eth->stats.tx_bytes += skb->len;
sipa_eth_tx_stats_update(dt_stats, skb->len);
return NETDEV_TX_OK;
err:
sipa_eth->netdev->stats.tx_dropped++;
dev_kfree_skb_any(skb);
return NETDEV_TX_OK;
}
static int sipa_eth_change_dev_list_state(struct SIPA_ETH *sipa_eth, int state) {
struct sipa_eth_netid_device *netid_dev_info;
int netid = sipa_eth->pdata->netid;
if (strncmp(sipa_eth->netdev->name,
SIPA_ETH_VPCIE_PREF,
strlen(SIPA_ETH_VPCIE_PREF)))
return 0;
if (netid < 0 || netid >= SIPA_DUMMY_IFACE_NUM) {
pr_info("illegal netid %d\n", netid);
return -EINVAL;
}
netid_dev_info = dev_list[netid];
netid_dev_info->state = state;
pr_info("set %s netid %d %s for dummy\n",
sipa_eth->netdev->name, netid, state ? "DEV_ON" : "DEV_OFF");
return 0;
}
/* Open interface */
static int sipa_eth_open(struct net_device *dev)
{
struct SIPA_ETH *sipa_eth = netdev_priv(dev);
struct sipa_eth_init_data *pdata = sipa_eth->pdata;
int ret = 0;
pr_info("dev 0x%p eth 0x%p open %s netid %d term %d mac_h %d\n",
dev, sipa_eth, dev->name, pdata->netid, pdata->term_type,
pdata->mac_h);
ret = sipa_nic_open(
pdata->term_type,
pdata->netid,
sipa_eth_notify_cb,
(void *)sipa_eth);
if (ret < 0)
return -EINVAL;
sipa_eth->nic_id = ret;
sipa_eth->state = DEV_ON;
sipa_eth_dt_stats_init(&sipa_eth->dt_stats);
memset(&sipa_eth->stats, 0, sizeof(sipa_eth->stats));
if (!netif_carrier_ok(sipa_eth->netdev)) {
pr_info("set netif_carrier_on\n");
netif_carrier_on(sipa_eth->netdev);
}
atomic_set(&sipa_eth->rx_busy, 0);
sipa_eth_change_dev_list_state(sipa_eth, DEV_ON);
netif_start_queue(dev);
napi_enable(&sipa_eth->napi);
return 0;
}
/* Close interface */
static int sipa_eth_close(struct net_device *dev)
{
struct SIPA_ETH *sipa_eth = netdev_priv(dev);
pr_info("close %s!\n", dev->name);
sipa_nic_close(sipa_eth->nic_id);
sipa_eth->state = DEV_OFF;
napi_disable(&sipa_eth->napi);
netif_stop_queue(dev);
sipa_eth_change_dev_list_state(sipa_eth, DEV_OFF);
return 0;
}
static struct net_device_stats *sipa_eth_get_stats(struct net_device *dev)
{
struct SIPA_ETH *sipa_eth = netdev_priv(dev);
return &sipa_eth->stats;
}
/*
* For example, if an application starts a tcp connection,
* it finally invokes tcp_connect func to send out a TCP SYN.
* In a func tcp_init_nondata_skb, the skb->ip_summed is set
* to CHECKSUM_PARTIAL. Because only the pesuode header is
* calculated and stored. It expects that the netdevice
* to calculate the checksum for TCP header&TCP paylod and store
* the final checksum into tcphdr->check.
* Then __dev_queue_xmit -> validate_xmit_skb, it check the features
* of this current network card, if it with
* NETIF_F_IP_CSUM/NETIF_F_IPV6_CSUM/NETIF_F_HW_CSUM,
* skb_checksum_help func will be invoked for this calculation.
*
* So we have to implement ndo_features_check func, since we
* have any ability to calculate a checksum for a pkt.
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION( 3,11,0 ))
netdev_features_t sipa_eth_features_check(struct sk_buff *skb, struct net_device *dev,
netdev_features_t features)
{
features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM);
return features;
}
#endif
static const struct net_device_ops sipa_eth_ops = {
.ndo_open = sipa_eth_open,
.ndo_stop = sipa_eth_close,
.ndo_start_xmit = sipa_eth_start_xmit,
.ndo_get_stats = sipa_eth_get_stats,
#if (LINUX_VERSION_CODE >= KERNEL_VERSION( 3,11,0 ))
.ndo_features_check = sipa_eth_features_check,
#endif
};
#if (LINUX_VERSION_CODE >= KERNEL_VERSION( 3,11,0 ))
static int sipa_eth_parse_dt(
struct sipa_eth_init_data **init,
struct device *dev)
{
struct sipa_eth_init_data *pdata = NULL;
struct device_node *np = dev->of_node;
int ret;
u32 udata, id;
s32 sdata;
if (!np)
pr_err("dev of_node np is null\n");
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return -ENOMEM;
id = of_alias_get_id(np, "eth");
switch (id) {
case 0 ... 7:
snprintf(pdata->name, IFNAMSIZ, "%s%d",
SIPA_ETH_IFACE_PREF, id);
break;
case 8 ... 11:
snprintf(pdata->name, IFNAMSIZ, "%s%d",
SIPA_ETH_VPCIE_PREF, id - SIPA_ETH_VPCIE_IDX);
break;
default:
pr_err("wrong alias id from dts, id %d\n", id);
return -EINVAL;
}
ret = of_property_read_u32(np, "sprd,netid", &sdata);
if (ret) {
pr_err("read sprd,netid ret %d\n", ret);
return ret;
}
/* dts reflect */
pdata->netid = sdata - 1;
ret = of_property_read_u32(np, "sprd,term-type", &udata);
if (ret) {
pr_err("read sprd,term-type ret %d\n", ret);
return ret;
}
pdata->term_type = udata;
pdata->mac_h = of_property_read_bool(np, "sprd,mac-header");
*init = pdata;
pr_debug("after dt parse, name %s netid %d term-type %d mac_h %d\n",
pdata->name, pdata->netid, pdata->term_type, pdata->mac_h);
return 0;
}
#endif
static void s_setup(struct net_device *dev)
{
#ifndef CONFIG_SPRD_ETHERNET
ether_setup(dev);
dev->needed_headroom = 16;
/* Raw IP mode */
dev->header_ops = NULL; /* No header */
dev->type = ARPHRD_RAWIP;
dev->hard_header_len = 0;
dev->flags |= IFF_NOARP | IFF_PROMISC;
dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
dev->addr_len = ETH_ALEN;
eth_hw_addr_random(dev);
#else
ether_setup(dev);
dev->flags |= IFF_PROMISC;
#endif
}
static ssize_t sipa_eth_get_direct_mode(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_dev(dev);
struct SIPA_ETH *sipa_eth = netdev_priv(netdev);
if (sipa_eth->pdata->term_type == 0x0)
return sprintf(buf, "\n %s in mode: normal\n", sipa_eth->netdev->name);
else if (sipa_eth->pdata->term_type == 0x6)
return sprintf(buf, "\n %s in mode: direct\n", sipa_eth->netdev->name);
else
return sprintf(buf, "\n %s in mode: illegal\n", sipa_eth->netdev->name);
}
static ssize_t sipa_eth_set_direct_mode(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_dev(dev);
struct SIPA_ETH *sipa_eth = netdev_priv(netdev);
if (!strncmp(buf, "normal", count - 1)) {
sipa_eth->pdata->term_type = 0x0;
} else if (!strncmp(buf, "direct", count - 1)) {
#ifndef CONFIG_SPRD_ETHERNET
sipa_eth->pdata->term_type = 0x6;
#else
pr_info("mode only can be set as normal when CONFIG_SPRD_ETHERNET is enabled!\n");
return -EINVAL;
#endif
} else {
return -EINVAL;
}
return count;
}
static DEVICE_ATTR(mode, 0664, sipa_eth_get_direct_mode, sipa_eth_set_direct_mode);
static struct attribute *sipa_eth_attributes[] = {
&dev_attr_mode.attr,
NULL,
};
static struct attribute_group sipa_eth_attribute_group = {
.attrs = sipa_eth_attributes,
};
#ifdef CONFIG_QCA_NSS_DRV
static rx_handler_result_t sipa_eth_rx_handler(struct sk_buff **pskb)
{
struct sk_buff *skb = *pskb;
struct rmnet_nss_cb *nss_cb;
if (!skb)
return RX_HANDLER_CONSUMED;
//printk("%s skb=%p, len=%d, protocol=%x, hdr_len=%d\n", __func__, skb, skb->len, skb->protocol, skb->hdr_len);
/* Check this so that we dont loop around netif_receive_skb */
if (skb->cb[0] == 1) {
skb->cb[0] = 0;
return RX_HANDLER_PASS;
}
nss_cb = rcu_dereference(rmnet_nss_callbacks);
if (nss_cb) {
nss_cb->nss_tx(skb);
return RX_HANDLER_CONSUMED;
}
return RX_HANDLER_PASS;
}
#endif
static int sipa_eth_probe(struct platform_device *pdev)
{
struct sipa_eth_netid_device *netid_dev_info = NULL;
struct sipa_eth_init_data *pdata = pdev->dev.platform_data;
struct net_device *netdev;
struct SIPA_ETH *sipa_eth;
char ifname[IFNAMSIZ];
int ret;
#ifdef CONFIG_QCA_NSS_DRV
struct rmnet_nss_cb *nss_cb;
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION( 3,11,0 ))
if (pdev->dev.of_node && !pdata) {
ret = sipa_eth_parse_dt(&pdata, &pdev->dev);
if (ret) {
pr_err("failed to parse device tree, ret=%d\n", ret);
return ret;
}
pdev->dev.platform_data = pdata;
}
#endif
strlcpy(ifname, pdata->name, IFNAMSIZ);
#ifdef NET_NAME_PREDICTABLE
netdev = alloc_netdev(
sizeof(struct SIPA_ETH),
ifname,
NET_NAME_PREDICTABLE,
s_setup);
#else
netdev = alloc_netdev(
sizeof(struct SIPA_ETH),
ifname,
s_setup);
#endif
if (!netdev) {
pr_err("alloc_netdev() failed.\n");
return -ENOMEM;
}
sipa_eth = netdev_priv(netdev);
sipa_eth_dt_stats_init(&sipa_eth->dt_stats);
sipa_eth->netdev = netdev;
sipa_eth->pdata = pdata;
atomic_set(&sipa_eth->rx_busy, 0);
atomic_set(&sipa_eth->rx_evt, 0);
netdev->netdev_ops = &sipa_eth_ops;
netdev->watchdog_timeo = 1 * HZ;
netdev->irq = 0;
netdev->dma = 0;
netdev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM);
//random_ether_addr(netdev->dev_addr);
eth_hw_addr_random(netdev);
netdev->sysfs_groups[0] = &sipa_eth_attribute_group;
netif_napi_add(netdev,
&sipa_eth->napi,
sipa_eth_rx_poll_handler,
SIPA_ETH_NAPI_WEIGHT);
/* Register new Ethernet interface */
ret = register_netdev(netdev);
if (ret) {
pr_err("register_netdev() failed (%d)\n", ret);
netif_napi_del(&sipa_eth->napi);
free_netdev(netdev);
return ret;
}
sipa_eth->state = DEV_OFF;
/* Set link as disconnected */
netif_carrier_off(netdev);
platform_set_drvdata(pdev, sipa_eth);
sipa_eth_debugfs_mknod(root, (void *)sipa_eth);
if (!strncmp(netdev->name, SIPA_ETH_VPCIE_PREF, strlen(SIPA_ETH_VPCIE_PREF))) {
netid_dev_info = kzalloc(sizeof(*netid_dev_info), GFP_ATOMIC);
if (!netid_dev_info)
return -ENOMEM;
#ifdef CONFIG_QCA_NSS_DRV
nss_cb = rcu_dereference(rmnet_nss_callbacks);
if (nss_cb) {
int rc = nss_cb->nss_create(netdev);
if (rc) {
/* Log, but don't fail the device creation */
netdev_err(netdev, "Device will not use NSS path: %d\n", rc);
} else {
netdev_info(netdev, "NSS context created\n");
rtnl_lock();
netdev_rx_handler_register(netdev, sipa_eth_rx_handler, NULL);
rtnl_unlock();
}
} else {
netdev_err(netdev, "nss_cb is null, Device will not use NSS path\n");
}
#endif
netid_dev_info->ndev = netdev;
netid_dev_info->napi = sipa_eth->napi;
netid_dev_info->state = DEV_OFF;
netid_dev_info->netid = pdata->netid;
dev_list[pdata->netid] = netid_dev_info;
}
//sysfs_create_group(&pdev->dev.kobj, &sipa_eth_attribute_group);
return 0;
}
/* Cleanup Ethernet device driver. */
static int sipa_eth_remove(struct platform_device *pdev)
{
struct SIPA_ETH *sipa_eth = platform_get_drvdata(pdev);
struct sipa_eth_init_data *pdata = pdev->dev.platform_data;
#ifdef CONFIG_QCA_NSS_DRV
struct rmnet_nss_cb *nss_cb;
rx_handler_func_t *rx_handler;
rcu_read_lock();
rx_handler = rcu_dereference(sipa_eth->netdev->rx_handler);
rcu_read_unlock();
nss_cb = rcu_dereference(rmnet_nss_callbacks);
if (nss_cb && rx_handler == sipa_eth_rx_handler) {
rtnl_lock();
netdev_rx_handler_unregister(sipa_eth->netdev);
rtnl_unlock();
nss_cb->nss_free(sipa_eth->netdev);
}
#endif
netif_napi_del(&sipa_eth->napi);
unregister_netdev(sipa_eth->netdev);
if(dev_list[pdata->netid]) {
kfree(dev_list[pdata->netid]);
dev_list[pdata->netid] = NULL;
}
if (!IS_ERR_OR_NULL(sipa_eth->subroot))
debugfs_remove_recursive(sipa_eth->subroot);
free_netdev(sipa_eth->netdev);
return 0;
}
#ifdef SPRD_PCIE_USE_DTS
static const struct of_device_id sipa_eth_match_table[] = {
{ .compatible = "sprd,sipa_eth"},
{ }
};
#endif
static struct platform_driver sipa_eth_driver = {
.probe = sipa_eth_probe,
.remove = sipa_eth_remove,
.driver = {
.owner = THIS_MODULE,
.name = SIPA_ETH_IFACE_PREF,
#ifdef SPRD_PCIE_USE_DTS
.of_match_table = sipa_eth_match_table
#endif
}
};
#ifndef SPRD_PCIE_USE_DTS
static struct platform_device *sipa_eth_pdev[SIPA_ETH_NUM];
static struct sipa_eth_init_data *sipa_eth_data[SIPA_ETH_NUM];
static int sipa_eth_platform_device_reigster(void)
{
int retval = -ENOMEM;
int i;
for(i = 0; i < SIPA_ETH_NUM; i++) {
sipa_eth_pdev[i] = platform_device_alloc(SIPA_ETH_IFACE_PREF, i);
if (!sipa_eth_pdev[i]) {
i--;
while (i >= 0)
platform_device_put(sipa_eth_pdev[i--]);
return retval;
}
}
for (i = 0; i < SIPA_ETH_NUM; i++) {
sipa_eth_data[i] = kzalloc(sizeof(struct sipa_eth_init_data), GFP_KERNEL);
if (!sipa_eth_data[i]) {
retval = -ENOMEM;
goto err_add_pdata;
}
snprintf(sipa_eth_data[i]->name, IFNAMSIZ, "%s%d",
SIPA_ETH_VPCIE_PREF, i);
#ifndef CONFIG_SPRD_ETHERNET
sipa_eth_data[i]->term_type = 0x6;
#else
sipa_eth_data[i]->term_type = 0x0;
#endif
sipa_eth_data[i]->netid = i;
sipa_eth_data[i]->mac_h = true;
retval = platform_device_add_data(sipa_eth_pdev[i], sipa_eth_data[i],
sizeof(struct sipa_eth_init_data));
if (retval)
goto err_add_pdata;
}
for (i = 0; i < SIPA_ETH_NUM; i++) {
retval = platform_device_add(sipa_eth_pdev[i]);
if (retval < 0) {
i--;
while (i >= 0)
platform_device_del(sipa_eth_pdev[i]);
goto err_add_pdata;
}
}
return retval;
err_add_pdata:
for (i = 0; i < SIPA_ETH_NUM; i++) {
if(sipa_eth_data[i])
kfree(sipa_eth_data[i]);
}
for (i = 0; i < SIPA_ETH_NUM; i++)
platform_device_put(sipa_eth_pdev[i]);
return retval;
}
static void sipa_eth_platform_device_unreigster(void)
{
int i;
for (i = 0; i < SIPA_ETH_NUM; i++) {
struct sipa_eth_init_data *init_data;
init_data = dev_get_platdata(&sipa_eth_pdev[i]->dev);
platform_device_unregister(sipa_eth_pdev[i]);
}
if (!IS_ERR_OR_NULL(root))
debugfs_remove_recursive(root);
}
#endif
static int sipa_eth_debug_show(struct seq_file *m, void *v)
{
struct SIPA_ETH *sipa_eth = (struct SIPA_ETH *)(m->private);
struct sipa_eth_dtrans_stats *stats;
struct sipa_eth_init_data *pdata;
int i;
if (!sipa_eth) {
pr_err("invalid data, sipa_eth is NULL\n");
return -EINVAL;
}
pdata = sipa_eth->pdata;
stats = &sipa_eth->dt_stats;
seq_puts(m, "*************************************************\n");
seq_printf(m, "DEVICE: %s, term_type %d, netid %d, state %s mac_h %d\n",
pdata->name, pdata->term_type, pdata->netid,
sipa_eth->state == DEV_ON ? "UP" : "DOWN", pdata->mac_h);
seq_puts(m, "\nRX statistics:\n");
seq_printf(m, "rx_sum=%u, rx_cnt=%u\n",
stats->rx_sum,
stats->rx_cnt);
seq_printf(m, "rx_fail=%u\n",
stats->rx_fail);
seq_printf(m, "rx_busy=%d\n", atomic_read(&sipa_eth->rx_busy));
seq_printf(m, "rx_evt=%d\n", atomic_read(&sipa_eth->rx_evt));
seq_puts(m, "\nTX statistics:\n");
seq_printf(m, "tx_sum=%u, tx_cnt=%u\n",
stats->tx_sum,
stats->tx_cnt);
seq_printf(m, "tx_fail=%u\n",
stats->tx_fail);
for (i = 0; i < SIPA_DUMMY_IFACE_NUM; i++) {
if(dev_list[i] == NULL) {
break;
}
seq_printf(m, "dev %s, netid %d state %d\n",
dev_list[i]->ndev->name, dev_list[i]->netid, dev_list[i]->state);
}
seq_puts(m, "*************************************************\n");
return 0;
}
static int sipa_eth_debug_open(struct inode *inode, struct file *file)
{
return single_open(file, sipa_eth_debug_show, inode->i_private);
}
static const struct file_operations sipa_eth_debug_fops = {
.open = sipa_eth_debug_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int debugfs_gro_enable_get(void *data, u64 *val)
{
*val = *(u64 *)data;
return 0;
}
static int debugfs_gro_enable_set(void *data, u64 val)
{
*(u64 *)data = val;
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(fops_gro_enable,
debugfs_gro_enable_get,
debugfs_gro_enable_set,
"%llu\n");
static int sipa_eth_debugfs_mknod(void *root, void *data)
{
struct SIPA_ETH *sipa_eth = (struct SIPA_ETH *)data;
struct dentry *subroot;
if (!sipa_eth)
return -ENODEV;
if (!root)
return -ENXIO;
subroot = debugfs_create_dir(sipa_eth->netdev->name, (struct dentry *)root);
if (!subroot)
return -ENOMEM;
sipa_eth->subroot = subroot;
debugfs_create_file("stats",
0444,
subroot,
data,
&sipa_eth_debug_fops);
debugfs_create_file("gro_enable",
0600,
(struct dentry *)root,
&gro_enable,
&fops_gro_enable);
return 0;
}
static void __init sipa_eth_debugfs_init(void)
{
root = debugfs_create_dir(SIPA_ETH_IFACE_PREF, NULL);
if (!root)
pr_err("failed to create sipa_eth debugfs dir\n");
}
int sipa_eth_init(void)
{
sipa_eth_debugfs_init();
#ifndef SPRD_PCIE_USE_DTS
sipa_eth_platform_device_reigster();
#endif
return platform_driver_register(&sipa_eth_driver);
}
EXPORT_SYMBOL(sipa_eth_init);
void sipa_eth_exit(void)
{
int i;
platform_driver_unregister(&sipa_eth_driver);
#ifndef SPRD_PCIE_USE_DTS
sipa_eth_platform_device_unreigster();
#endif
for (i = 0; i < SIPA_ETH_NUM; i++) {
if(sipa_eth_data[i]){
kfree(sipa_eth_data[i]);
}
}
}
EXPORT_SYMBOL(sipa_eth_exit);
Reference in New Issue View Git Blame Copy Permalink