* [PATCH 01/31] cobalt uapi: Introducing new feature flag for time64 availability
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 02/31] net/stack: plan for merging private device flags with netdev_priv_flags Jean-Baptiste Trédez
` (31 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Florian Bezdeka <florian.bezdeka@siemens.com>
Adding a new feature flag to allow the library asking for time64
support. That will allow the library to use the new system calls when
available / supported by the kernel.
The feature flag should be removed during next ABI revision bump.
Signed-off-by: Florian Bezdeka <florian.bezdeka@siemens.com>
Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
---
include/cobalt/uapi/asm-generic/features.h | 6 +++++-
.../cobalt/arch/arm64/include/asm/xenomai/uapi/features.h | 1 +
.../cobalt/arch/powerpc/include/asm/xenomai/uapi/features.h | 1 +
kernel/cobalt/arch/x86/include/asm/xenomai/uapi/features.h | 1 +
4 files changed, 8 insertions(+), 1 deletion(-)
diff --git a/include/cobalt/uapi/asm-generic/features.h b/include/cobalt/uapi/asm-generic/features.h
index 8a4927c49..705729aae 100644
--- a/include/cobalt/uapi/asm-generic/features.h
+++ b/include/cobalt/uapi/asm-generic/features.h
@@ -51,6 +51,7 @@ struct cobalt_featinfo {
#define __xn_feat_nofastsynch 0x10000000
#define __xn_feat_control 0x08000000
#define __xn_feat_prioceiling 0x04000000
+#define __xn_feat_time64 0x02000000
#ifdef CONFIG_SMP
#define __xn_feat_smp_mask __xn_feat_smp
@@ -70,7 +71,8 @@ struct cobalt_featinfo {
#define __xn_feat_generic_mask \
(__xn_feat_smp_mask | \
__xn_feat_fastsynch_mask | \
- __xn_feat_prioceiling)
+ __xn_feat_prioceiling | \
+ __xn_feat_time64)
/*
* List of features both sides have to agree on: If userland supports
@@ -101,6 +103,8 @@ const char *get_generic_feature_label(unsigned int feature)
return "control";
case __xn_feat_prioceiling:
return "prioceiling";
+ case __xn_feat_time64:
+ return "time64";
default:
return 0;
}
diff --git a/kernel/cobalt/arch/arm64/include/asm/xenomai/uapi/features.h b/kernel/cobalt/arch/arm64/include/asm/xenomai/uapi/features.h
index 74423f68b..f03f483f6 100644
--- a/kernel/cobalt/arch/arm64/include/asm/xenomai/uapi/features.h
+++ b/kernel/cobalt/arch/arm64/include/asm/xenomai/uapi/features.h
@@ -22,6 +22,7 @@
#define _COBALT_ARM64_ASM_UAPI_FEATURES_H
/* The ABI revision level we use on this arch. */
+// TODO: Reminder: Remove __xn_feat_time64 feature flag on next ABI_REV bump
#define XENOMAI_ABI_REV 1UL
#define XENOMAI_FEAT_DEP (__xn_feat_generic_mask)
diff --git a/kernel/cobalt/arch/powerpc/include/asm/xenomai/uapi/features.h b/kernel/cobalt/arch/powerpc/include/asm/xenomai/uapi/features.h
index f6e67d884..db6dbed24 100644
--- a/kernel/cobalt/arch/powerpc/include/asm/xenomai/uapi/features.h
+++ b/kernel/cobalt/arch/powerpc/include/asm/xenomai/uapi/features.h
@@ -19,6 +19,7 @@
#define _COBALT_POWERPC_ASM_UAPI_FEATURES_H
/* The ABI revision level we use on this arch. */
+// TODO: Reminder: Remove __xn_feat_time64 feature flag on next ABI_REV bump
#define XENOMAI_ABI_REV 17UL
#define XENOMAI_FEAT_DEP __xn_feat_generic_mask
diff --git a/kernel/cobalt/arch/x86/include/asm/xenomai/uapi/features.h b/kernel/cobalt/arch/x86/include/asm/xenomai/uapi/features.h
index 67c7625f8..30539a5d1 100644
--- a/kernel/cobalt/arch/x86/include/asm/xenomai/uapi/features.h
+++ b/kernel/cobalt/arch/x86/include/asm/xenomai/uapi/features.h
@@ -19,6 +19,7 @@
#define _COBALT_X86_ASM_UAPI_FEATURES_H
/* The ABI revision level we use on this arch. */
+// TODO: Reminder: Remove __xn_feat_time64 feature flag on next ABI_REV bump
#define XENOMAI_ABI_REV 17UL
#define XENOMAI_FEAT_DEP __xn_feat_generic_mask
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 02/31] net/stack: plan for merging private device flags with netdev_priv_flags
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 01/31] cobalt uapi: Introducing new feature flag for time64 availability Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 03/31] net/stack: add multicast support Jean-Baptiste Trédez
` (30 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
We need to merge regular netdev_priv_flags with our own private device
flags for the upcoming VLAN, multicast support. Pick non-conflicting
bit positions.
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/include/rtdev.h | 9 +++++++--
1 file changed, 7 insertions(+), 2 deletions(-)
diff --git a/kernel/drivers/net/stack/include/rtdev.h b/kernel/drivers/net/stack/include/rtdev.h
index a4d963fcb..3a9f6f8ee 100644
--- a/kernel/drivers/net/stack/include/rtdev.h
+++ b/kernel/drivers/net/stack/include/rtdev.h
@@ -38,8 +38,13 @@
#define RTDEV_VERS_2_0 0x0200
-#define PRIV_FLAG_UP 0
-#define PRIV_FLAG_ADDING_ROUTE 1
+/*
+ * We need to merge regular netdev_priv_flags with our own private
+ * device flags for VLAN, multicast support. Pick non-conflicting bit
+ * positions.
+ */
+#define PRIV_FLAG_UP 30
+#define PRIV_FLAG_ADDING_ROUTE 31
#ifndef NETIF_F_LLTX
#define NETIF_F_LLTX 4096
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 03/31] net/stack: add multicast support
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 01/31] cobalt uapi: Introducing new feature flag for time64 availability Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 02/31] net/stack: plan for merging private device flags with netdev_priv_flags Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 04/31] utils/net: rtifconfig: display device name untruncated Jean-Baptiste Trédez
` (29 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/include/ipv4/arp.h | 3 +
kernel/drivers/net/stack/include/ipv4/igmp.h | 102 +++
.../drivers/net/stack/include/ipv4/protocol.h | 1 +
kernel/drivers/net/stack/include/rtdev.h | 17 +
.../drivers/net/stack/include/rtnet_socket.h | 4 +
kernel/drivers/net/stack/include/rtskb.h | 1 +
kernel/drivers/net/stack/ipv4/Kconfig | 7 +
kernel/drivers/net/stack/ipv4/Makefile | 1 +
kernel/drivers/net/stack/ipv4/af_inet.c | 5 +
kernel/drivers/net/stack/ipv4/arp.c | 26 +
kernel/drivers/net/stack/ipv4/igmp.c | 616 ++++++++++++++++++
kernel/drivers/net/stack/ipv4/ip_output.c | 13 +-
kernel/drivers/net/stack/ipv4/ip_sock.c | 70 +-
kernel/drivers/net/stack/ipv4/protocol.c | 17 +
kernel/drivers/net/stack/ipv4/tcp/tcp.c | 2 +-
kernel/drivers/net/stack/ipv4/udp/udp.c | 41 +-
kernel/drivers/net/stack/rtdev.c | 202 ++++++
17 files changed, 1117 insertions(+), 11 deletions(-)
create mode 100644 kernel/drivers/net/stack/include/ipv4/igmp.h
create mode 100644 kernel/drivers/net/stack/ipv4/igmp.c
diff --git a/kernel/drivers/net/stack/include/ipv4/arp.h b/kernel/drivers/net/stack/include/ipv4/arp.h
index cf037a18b..ee67478c2 100644
--- a/kernel/drivers/net/stack/include/ipv4/arp.h
+++ b/kernel/drivers/net/stack/include/ipv4/arp.h
@@ -48,4 +48,7 @@ static inline void rt_arp_solicit(struct rtnet_device *rtdev, u32 target)
void __init rt_arp_init(void);
void rt_arp_release(void);
+int rt_arp_mc_map(u32 addr, u8 *haddr,
+ struct rtnet_device *dev, int dir);
+
#endif /* __RTNET_ARP_H_ */
diff --git a/kernel/drivers/net/stack/include/ipv4/igmp.h b/kernel/drivers/net/stack/include/ipv4/igmp.h
new file mode 100644
index 000000000..a44e09041
--- /dev/null
+++ b/kernel/drivers/net/stack/include/ipv4/igmp.h
@@ -0,0 +1,102 @@
+/*
+ * include/ipv4/igmp.h - Internet Group Management Protocol [IGMP]
+ *
+ * Adapted from linux/igmp.h to RTnet by:
+ * Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
+ * Original author:
+ * Alan Cox <Alan.Cox@linux.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef __RTNET_IGMP_H_
+#define __RTNET_IGMP_H_
+#include <asm/byteorder.h>
+#include <linux/init.h>
+#include <linux/kconfig.h>
+#include <linux/in.h>
+#include <rtnet_socket.h>
+
+struct igmphdr {
+ __u8 type;
+ __u8 code; /* For newer IGMP */
+ __u16 csum;
+ __u32 group;
+};
+
+#define IGMP_HOST_MEMBERSHIP_QUERY 0x11 /* From RFC1112 */
+#define IGMP_HOST_MEMBERSHIP_REPORT 0x12 /* Ditto */
+#define IGMP_DVMRP 0x13 /* DVMRP routing */
+#define IGMP_PIM 0x14 /* PIM routing */
+#define IGMP_TRACE 0x15
+#define IGMP_HOST_NEW_MEMBERSHIP_REPORT 0x16 /* New version of 0x11 */
+#define IGMP_HOST_LEAVE_MESSAGE 0x17
+
+#define IGMP_MTRACE_RESP 0x1e
+#define IGMP_MTRACE 0x1f
+
+#define IGMP_DELAYING_MEMBER 0x01
+#define IGMP_IDLE_MEMBER 0x02
+#define IGMP_LAZY_MEMBER 0x03
+#define IGMP_SLEEPING_MEMBER 0x04
+#define IGMP_AWAKENING_MEMBER 0x05
+
+#define IGMP_MINLEN 8
+
+#define IGMP_MAX_HOST_REPORT_DELAY 10 /* max delay for response to */
+ /* query (in seconds) */
+
+#define IGMP_TIMER_SCALE 10 /* denotes that the igmphdr->timer field */
+ /* specifies time in 10th of seconds */
+
+#define IGMP_AGE_THRESHOLD 400 /* If this host don't hear any IGMP V1 */
+ /* message in this period of time, */
+ /* revert to IGMP v2 router. */
+
+#define IGMP_ALL_HOSTS htonl(0xE0000001L)
+#define IGMP_ALL_ROUTER htonl(0xE0000002L)
+#define IGMP_LOCAL_GROUP htonl(0xE0000000L)
+#define IGMP_LOCAL_GROUP_MASK htonl(0xFFFFFF00L)
+
+enum rtip_mc_state {
+ RTIP_MC_NON_MEMBER,
+ RTIP_MC_DELAYING_MEMBER,
+ RTIP_MC_IDLE_MEMBER,
+};
+
+struct rtip_mc_socklist {
+ struct rtip_mc_socklist *next;
+ struct ip_mreq multi;
+};
+
+struct rtip_mc_list {
+ struct rtnet_device *interface;
+ u32 multiaddr;
+ struct rtip_mc_list *next;
+ int users;
+ enum rtip_mc_state state;
+};
+
+static inline bool rtnet_in_multicast(u32 addr)
+{
+ return IS_ENABLED(CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP) &&
+ IN_MULTICAST(addr);
+}
+
+#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP
+int rt_ip_mc_join_group(struct rtsocket *sk, struct ip_mreq *imr);
+int rt_ip_mc_leave_group(struct rtsocket *sk, struct ip_mreq *imr);
+void rt_ip_mc_drop_socket(struct rtsocket *sk);
+void rt_ip_mc_dec_group(struct rtnet_device *rtdev, u32 addr);
+void rt_ip_mc_inc_group(struct rtnet_device *rtdev, u32 addr);
+void rt_igmp_init(void);
+void rt_igmp_release(void);
+#else
+static inline void rt_igmp_init(void) { }
+static inline void rt_igmp_release(void) { }
+#endif
+
+#endif /* __RTNET_IGMP_H_ */
diff --git a/kernel/drivers/net/stack/include/ipv4/protocol.h b/kernel/drivers/net/stack/include/ipv4/protocol.h
index 1df42db67..dc31fb2cc 100644
--- a/kernel/drivers/net/stack/include/ipv4/protocol.h
+++ b/kernel/drivers/net/stack/include/ipv4/protocol.h
@@ -50,5 +50,6 @@ extern struct rtinet_protocol *rt_inet_protocols[];
extern void rt_inet_add_protocol(struct rtinet_protocol *prot);
extern void rt_inet_del_protocol(struct rtinet_protocol *prot);
extern int rt_inet_socket(struct rtdm_fd *fd, int protocol);
+extern int rt_inet_socket_cleanup(struct rtdm_fd *fd);
#endif /* __RTNET_PROTOCOL_H_ */
diff --git a/kernel/drivers/net/stack/include/rtdev.h b/kernel/drivers/net/stack/include/rtdev.h
index 3a9f6f8ee..e5a6bf920 100644
--- a/kernel/drivers/net/stack/include/rtdev.h
+++ b/kernel/drivers/net/stack/include/rtdev.h
@@ -64,6 +64,14 @@ enum rtnet_link_state {
#define RTNET_LINK_STATE_PRESENT (1 << __RTNET_LINK_STATE_PRESENT)
#define RTNET_LINK_STATE_NOCARRIER (1 << __RTNET_LINK_STATE_NOCARRIER)
+struct rtdev_mc_list {
+ struct rtdev_mc_list *next;
+ __u8 dmi_addr[MAX_ADDR_LEN];
+ unsigned char dmi_addrlen;
+ int dmi_users;
+ int dmi_gusers;
+};
+
/***
* rtnet_device
*/
@@ -114,6 +122,8 @@ struct rtnet_device {
int promiscuity;
int allmulti;
+ struct rtdev_mc_list *mc_list;
+ int mc_count;
__u32 local_ip; /* IP address in network order */
__u32 broadcast_ip; /* broadcast IP in network order */
@@ -142,6 +152,7 @@ struct rtnet_device {
int (*rebuild_header)(struct rtskb *);
int (*hard_start_xmit)(struct rtskb *skb, struct rtnet_device *dev);
int (*hw_reset)(struct rtnet_device *rtdev);
+ void (*set_multicast_list) (struct rtnet_device *rtdev);
/* Transmission hook, managed by the stack core, RTcap, and RTmac
*
@@ -244,6 +255,12 @@ void rtdev_unmap_rtskb(struct rtskb *skb);
struct rtskb *rtnetdev_alloc_rtskb(struct rtnet_device *dev, unsigned int size);
+struct rtnet_device *rt_ip_dev_find(u32 addr);
+void rt_dev_mc_upload(struct rtnet_device *dev);
+int rt_dev_mc_delete(struct rtnet_device *dev, void *addr, int alen, int all);
+int rt_dev_mc_add(struct rtnet_device *dev, void *addr, int alen, int newonly);
+void rt_dev_set_allmulti(struct rtnet_device *dev, int inc);
+
#define rtnetdev_priv(dev) ((dev)->priv)
#define rtdev_emerg(__dev, format, args...) \
diff --git a/kernel/drivers/net/stack/include/rtnet_socket.h b/kernel/drivers/net/stack/include/rtnet_socket.h
index d2caab649..af972c1a5 100644
--- a/kernel/drivers/net/stack/include/rtnet_socket.h
+++ b/kernel/drivers/net/stack/include/rtnet_socket.h
@@ -35,6 +35,8 @@
#include <rtdm/driver.h>
#include <stack_mgr.h>
+struct rtip_mc_socklist;
+
struct rtsocket {
unsigned short protocol;
@@ -67,6 +69,8 @@ struct rtsocket {
int reg_index; /* index in port registry */
u8 tos;
u8 state;
+ struct rtip_mc_socklist *mc_list;
+ u32 mc_if_addr;
} inet;
/* packet socket specific */
diff --git a/kernel/drivers/net/stack/include/rtskb.h b/kernel/drivers/net/stack/include/rtskb.h
index 522b66715..4277fa6c6 100644
--- a/kernel/drivers/net/stack/include/rtskb.h
+++ b/kernel/drivers/net/stack/include/rtskb.h
@@ -177,6 +177,7 @@ struct rtskb {
struct icmphdr *icmph;
struct iphdr *ipihdr;
unsigned char *raw;
+ struct igmphdr *igmph;
} h;
/* network layer */
diff --git a/kernel/drivers/net/stack/ipv4/Kconfig b/kernel/drivers/net/stack/ipv4/Kconfig
index d5a6cd6d7..efe807915 100644
--- a/kernel/drivers/net/stack/ipv4/Kconfig
+++ b/kernel/drivers/net/stack/ipv4/Kconfig
@@ -62,6 +62,13 @@ config XENO_DRIVERS_NET_RTIPV4_ROUTER
See Documentation/README.routing for further information.
+config XENO_DRIVERS_NET_RTIPV4_IGMP
+ bool "IGMP/multicast support"
+ depends on XENO_DRIVERS_NET_RTIPV4
+ default n
+ ---help---
+ Enables IGMP support of the RTnet Real-Time IPv4 protocol (multicast).
+
config XENO_DRIVERS_NET_RTIPV4_DEBUG
bool "RTipv4 Debugging"
depends on XENO_DRIVERS_NET_RTIPV4
diff --git a/kernel/drivers/net/stack/ipv4/Makefile b/kernel/drivers/net/stack/ipv4/Makefile
index afdbeafce..d3a8b0c2d 100644
--- a/kernel/drivers/net/stack/ipv4/Makefile
+++ b/kernel/drivers/net/stack/ipv4/Makefile
@@ -17,3 +17,4 @@ obj-$(CONFIG_XENO_DRIVERS_NET_RTIPV4_UDP) += udp/
obj-$(CONFIG_XENO_DRIVERS_NET_RTIPV4_TCP) += tcp/
rtipv4-$(CONFIG_XENO_DRIVERS_NET_RTIPV4_ICMP) += icmp.o
+rtipv4-$(CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP) += igmp.o
diff --git a/kernel/drivers/net/stack/ipv4/af_inet.c b/kernel/drivers/net/stack/ipv4/af_inet.c
index 8bc87d90b..0081e0894 100644
--- a/kernel/drivers/net/stack/ipv4/af_inet.c
+++ b/kernel/drivers/net/stack/ipv4/af_inet.c
@@ -34,6 +34,7 @@
#include <ipv4/ip_output.h>
#include <ipv4/protocol.h>
#include <ipv4/route.h>
+#include <ipv4/igmp.h>
MODULE_LICENSE("GPL");
@@ -283,6 +284,7 @@ static int __init rt_ipv4_proto_init(void)
rt_inet_protocols[i] = NULL;
rt_icmp_init();
+ rt_igmp_init();
#ifdef CONFIG_XENO_OPT_VFILE
result = xnvfile_init_dir("ipv4", &ipv4_proc_root, &rtnet_proc_root);
@@ -308,6 +310,7 @@ err2:
err1:
#endif /* CONFIG_XENO_OPT_VFILE */
+ rt_igmp_release();
rt_icmp_release();
rt_arp_release();
rt_ip_release();
@@ -327,6 +330,8 @@ static void __exit rt_ipv4_proto_release(void)
xnvfile_destroy_dir(&ipv4_proc_root);
#endif
+ rt_igmp_release();
+
/* Transport-Layer */
rt_icmp_release();
diff --git a/kernel/drivers/net/stack/ipv4/arp.c b/kernel/drivers/net/stack/ipv4/arp.c
index 91c151e90..35c6c8f7e 100644
--- a/kernel/drivers/net/stack/ipv4/arp.c
+++ b/kernel/drivers/net/stack/ipv4/arp.c
@@ -21,6 +21,8 @@
*
*/
+#include <net/ip.h>
+#include <linux/if_arp.h>
#include <rtdev.h>
#include <stack_mgr.h>
#include <ipv4/arp.h>
@@ -195,6 +197,30 @@ static struct rtpacket_type arp_packet_type = {
handler: &rt_arp_rcv
};
+/* Multicast mapping */
+
+#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP
+
+int rt_arp_mc_map(u32 addr, u8 *haddr, struct rtnet_device *dev, int dir)
+{
+ switch (dev->type) {
+ case ARPHRD_ETHER:
+ case ARPHRD_FDDI:
+ case ARPHRD_IEEE802:
+ ip_eth_mc_map(addr, haddr);
+ return 0;
+ default:
+ if (dir) {
+ memcpy(haddr, dev->broadcast, dev->addr_len);
+ return 0;
+ }
+ }
+ return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(rt_arp_mc_map);
+
+#endif
+
/***
* rt_arp_init
*/
diff --git a/kernel/drivers/net/stack/ipv4/igmp.c b/kernel/drivers/net/stack/ipv4/igmp.c
new file mode 100644
index 000000000..3da21df5b
--- /dev/null
+++ b/kernel/drivers/net/stack/ipv4/igmp.c
@@ -0,0 +1,616 @@
+/*
+ * ipv4/igmp.c - Internet Group Management Protocol [IGMP]
+ *
+ * Adapted from net/ipv4/igmp.c to RTnet by:
+ * Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
+ * Original author:
+ * Alan Cox <Alan.Cox@linux.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Fixes:
+ *
+ * Alan Cox : Added lots of __inline__ to optimise
+ * the memory usage of all the tiny little
+ * functions.
+ * Alan Cox : Dumped the header building experiment.
+ * Alan Cox : Minor tweaks ready for multicast routing
+ * and extended IGMP protocol.
+ * Alan Cox : Removed a load of inline directives. Gcc 2.5.8
+ * writes utterly bogus code otherwise (sigh)
+ * fixed IGMP loopback to behave in the manner
+ * desired by mrouted, fixed the fact it has been
+ * broken since 1.3.6 and cleaned up a few minor
+ * points.
+ *
+ * Chih-Jen Chang : Tried to revise IGMP to Version 2
+ * Tsu-Sheng Tsao E-mail: chihjenc@scf.usc.edu and tsusheng@scf.usc.edu
+ * The enhancements are mainly based on Steve Deering's
+ * ipmulti-3.5 source code.
+ * Chih-Jen Chang : Added the igmp_get_mrouter_info and
+ * Tsu-Sheng Tsao igmp_set_mrouter_info to keep track of
+ * the mrouted version on that device.
+ * Chih-Jen Chang : Added the max_resp_time parameter to
+ * Tsu-Sheng Tsao igmp_heard_query(). Using this parameter
+ * to identify the multicast router version
+ * and do what the IGMP version 2 specified.
+ * Chih-Jen Chang : Added a timer to revert to IGMP V2 router
+ * Tsu-Sheng Tsao if the specified time expired.
+ * Alan Cox : Stop IGMP from 0.0.0.0 being accepted.
+ * Alan Cox : Use GFP_ATOMIC in the right places.
+ * Christian Daudt : igmp timer wasn't set for local group
+ * memberships but was being deleted,
+ * which caused a "del_timer() called
+ * from %p with timer not initialized\n"
+ * message (960131).
+ * Christian Daudt : removed del_timer from
+ * igmp_timer_expire function (960205).
+ * Christian Daudt : igmp_heard_report now only calls
+ * igmp_timer_expire if tm->running is
+ * true (960216).
+ * Malcolm Beattie : ttl comparison wrong in igmp_rcv made
+ * igmp_heard_query never trigger. Expiry
+ * miscalculation fixed in igmp_heard_query
+ * and random() made to return unsigned to
+ * prevent negative expiry times.
+ * Alexey Kuznetsov: Wrong group leaving behaviour, backport
+ * fix from pending 2.1.x patches.
+ * Alan Cox: Forget to enable FDDI support earlier.
+ * Alexey Kuznetsov: Fixed leaving groups on device down.
+ * Alexey Kuznetsov: Accordance to igmp-v2-06 draft.
+ */
+
+#include <ipv4/igmp.h>
+#include <net/checksum.h>
+#include <net/ip.h>
+#include <rtnet_socket.h>
+#include <rtdev.h>
+#include <ipv4/protocol.h>
+#include <ipv4/route.h>
+#include <ipv4/arp.h>
+
+#define IGMP_REPLY_POOL_SIZE 8
+#define IP_MAX_MEMBERSHIPS 20
+#define RT_IGMP_SKB_PRIO RTSKB_PRIO_VALUE(QUEUE_MIN_PRIO-1, \
+ RTSKB_DEF_NRT_CHANNEL)
+/***
+ * It is not part of the socket pool. It may furthermore be used concurrently
+ * by multiple tasks because all fields are static excect skb_pool, but that
+ * is spin lock protected.
+ */
+static struct rtsocket igmp_socket;
+static struct rtip_mc_list *mc_list;
+static rtdm_lock_t mc_list_lock;
+static rtdm_mutex_t mc_socklist_lock;
+rtdm_task_t rtnet_igmp_task;
+
+#define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4)
+
+static int rt_igmp_send_report(struct rtnet_device *rtdev, u32 group, int type)
+{
+ struct rtskb *skb;
+ struct iphdr *iph;
+ struct igmphdr *ih;
+ struct dest_route rt;
+ u32 dst;
+ int len;
+ int err;
+ char buf[MAX_ADDR_LEN];
+ /* According to IGMPv2 specs, LEAVE messages are
+ * sent to all-routers group.
+ */
+ dst = group;
+ if (type == IGMP_HOST_LEAVE_MESSAGE)
+ dst = IGMP_ALL_ROUTER;
+ if (rt_arp_mc_map(dst, buf, rtdev, 0) == 0) {
+ memcpy(rt.dev_addr, buf, sizeof(buf));
+ rt.rtdev = rtdev;
+ rt.ip = dst;
+ }
+
+ len = (rtdev->hard_header_len + 15) & ~15;
+ skb = alloc_rtskb(len + IGMP_SIZE + 15, &global_pool);
+ if (skb == NULL) {
+ printk("can't alloc rtskb \n");
+ return -ENOMEM;
+ }
+
+ skb->rtdev = rtdev;
+ skb->priority = RT_IGMP_SKB_PRIO;
+ rtskb_reserve(skb, len);
+ skb->nh.iph = iph = (struct iphdr *)rtskb_put(skb, sizeof(*iph) + 4);
+ iph->version = 4;
+ iph->ihl = (sizeof(struct iphdr) + 4) >> 2;
+ iph->tos = 0xc0;
+ iph->frag_off = htons(IP_DF);
+ iph->ttl = 1;
+ iph->daddr = rt.ip;
+ iph->saddr = rtdev->local_ip;
+ iph->protocol = IPPROTO_IGMP;
+ iph->tot_len = htons(IGMP_SIZE);
+ iph->id = htons(0);
+ ((u8 *) & iph[1])[0] = IPOPT_RA;
+ ((u8 *) & iph[1])[1] = 4;
+ ((u8 *) & iph[1])[2] = 0;
+ ((u8 *) & iph[1])[3] = 0;
+ ip_send_check(iph);
+ ih = (struct igmphdr *)rtskb_put(skb, sizeof(struct igmphdr));
+ ih->type = type;
+ ih->code = 0;
+ ih->csum = 0;
+ ih->group = group;
+ ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr));
+
+ if (rtdev->hard_header) {
+ err = rtdev->hard_header(skb, rtdev, ETH_P_IP, rt.dev_addr,
+ rtdev->dev_addr, skb->len);
+ if (err < 0) {
+ kfree_rtskb(skb);
+ return err;
+ }
+ }
+
+ return rtdev_xmit(skb);
+}
+
+static void igmp_heard_query(struct rtnet_device *rtdev, u32 group)
+{
+ struct rtip_mc_list *im;
+ unsigned long flags;
+
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (im = mc_list; im != NULL; im = im->next)
+ if (im->multiaddr != IGMP_ALL_HOSTS
+ && (!group || im->multiaddr == group))
+ im->state = RTIP_MC_DELAYING_MEMBER;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+}
+
+static void igmp_heard_report(struct rtnet_device *rtdev, u32 group)
+{
+ struct rtip_mc_list *im;
+ unsigned long flags;
+
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (im = mc_list; im != NULL; im = im->next)
+ if (im->multiaddr == group
+ && im->state == RTIP_MC_DELAYING_MEMBER)
+ im->state = RTIP_MC_IDLE_MEMBER;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+}
+
+void rt_igmp_rcv(struct rtskb *skb)
+{
+ /* This basically follows the spec line by line -- see RFC1112 */
+ struct igmphdr *ih = skb->h.igmph;
+ struct rtnet_device *rtdev = skb->rtdev;
+ int len = skb->len;
+ if (len < sizeof(struct igmphdr) || ip_compute_csum((void *)ih, len))
+ goto cleanup;
+
+ switch (ih->type) {
+ case IGMP_HOST_MEMBERSHIP_QUERY:
+ igmp_heard_query(rtdev, ih->group);
+ break;
+ case IGMP_HOST_MEMBERSHIP_REPORT:
+ case IGMP_HOST_NEW_MEMBERSHIP_REPORT:
+ igmp_heard_report(rtdev, ih->group);
+ break;
+ case IGMP_PIM:
+ case IGMP_DVMRP:
+ case IGMP_TRACE:
+ case IGMP_HOST_LEAVE_MESSAGE:
+ case IGMP_MTRACE:
+ case IGMP_MTRACE_RESP:
+ break;
+ default:
+ rtdm_printk(KERN_DEBUG
+ "New IGMP type=0x%x, why we do not know about it?\n",
+ ih->type);
+ }
+
+cleanup:
+ kfree_rtskb(skb);
+}
+
+/*
+ * Add a filter to a device
+ */
+static void rt_ip_mc_filter_add(struct rtnet_device *rtdev, u32 addr)
+{
+ char buf[MAX_ADDR_LEN];
+
+ /* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG.
+ We will get multicast token leakage, when IFF_MULTICAST
+ is changed. This check should be done in dev->set_multicast_list
+ routine. Something sort of:
+ if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; }
+ --ANK
+ */
+ if (rt_arp_mc_map(addr, buf, rtdev, 0) == 0)
+ rt_dev_mc_add(rtdev, buf, rtdev->addr_len, 0);
+}
+
+/*
+ * Remove a filter from a device
+ */
+static void rt_ip_mc_filter_del(struct rtnet_device *rtdev, u32 addr)
+{
+ char buf[MAX_ADDR_LEN];
+ struct rtnet_device *dev = rtdev;
+
+ if (rt_arp_mc_map(addr, buf, dev, 0) == 0)
+ rt_dev_mc_delete(dev, buf, dev->addr_len, 0);
+}
+
+static void igmp_group_dropped(struct rtip_mc_list *im)
+{
+ unsigned long flags;
+ enum rtip_mc_state oldstate;
+
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ oldstate = im->state;
+ if (oldstate != RTIP_MC_NON_MEMBER)
+ im->state = RTIP_MC_NON_MEMBER;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ if (oldstate != RTIP_MC_NON_MEMBER)
+ rt_ip_mc_filter_del(im->interface, im->multiaddr);
+}
+
+static void igmp_group_added(struct rtip_mc_list *im)
+{
+ unsigned long flags;
+ enum rtip_mc_state oldstate;
+
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ oldstate = im->state;
+ if (oldstate == RTIP_MC_NON_MEMBER) {
+ if (im->multiaddr == IGMP_ALL_HOSTS)
+ im->state = RTIP_MC_IDLE_MEMBER;
+ else
+ im->state = RTIP_MC_DELAYING_MEMBER;
+ }
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ if (oldstate != RTIP_MC_NON_MEMBER) {
+ return;
+ }
+
+ rt_ip_mc_filter_add(im->interface, im->multiaddr);
+
+ if (im->multiaddr != IGMP_ALL_HOSTS && rtdm_in_rt_context())
+ rt_igmp_send_report(im->interface,
+ im->multiaddr, IGMP_HOST_MEMBERSHIP_REPORT);
+}
+
+void rt_ip_mc_inc_group(struct rtnet_device *rtdev, u32 addr)
+{
+ struct rtip_mc_list *im, *iml;
+ unsigned long flags;
+
+ iml = rtdm_malloc(sizeof(*im));
+ if (!iml)
+ return;
+ iml->users = 1;
+ iml->interface = rtdev;
+ iml->multiaddr = addr;
+ iml->state = RTIP_MC_NON_MEMBER;
+
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (im = mc_list; im; im = im->next) {
+ if (im->multiaddr == addr && im->interface == rtdev) {
+ im->users++;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+ rtdm_free(iml);
+ return;
+ }
+ }
+ iml->next = mc_list;
+ mc_list = iml;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ igmp_group_added(iml);
+}
+
+/*
+ * A socket has left a multicast group on device dev
+ */
+void rt_ip_mc_dec_group(struct rtnet_device *rtdev, u32 addr)
+{
+ struct rtip_mc_list *i, **ip;
+ unsigned long flags;
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (ip = &mc_list; (i = *ip) != NULL; ip = &i->next) {
+ if (i->multiaddr == addr && i->interface == rtdev) {
+ if (--i->users == 0) {
+ *ip = i->next;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+ igmp_group_dropped(i);
+ rtdm_free(i);
+ return;
+ }
+ break;
+ }
+ }
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+}
+
+static struct rtnet_device *rt_ip_mc_find_dev(struct ip_mreq *imr)
+{
+ struct rtnet_device *rtdev = NULL;
+
+ if (imr->imr_interface.s_addr)
+ rtdev = rt_ip_dev_find(imr->imr_interface.s_addr);
+
+ return rtdev;
+}
+
+/*
+ * Join a socket to a group
+ */
+
+int rt_ip_mc_join_group(struct rtsocket *sk, struct ip_mreq *imr)
+{
+ int err = 0;
+ u32 addr = imr->imr_multiaddr.s_addr;
+ struct rtnet_device *rtdev = rt_ip_mc_find_dev(imr);
+ struct rtip_mc_socklist *i, *iml;
+
+ if (!rtdev)
+ return -ENODEV;
+
+ if (!IN_MULTICAST(ntohl(addr))) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ iml = rtdm_malloc(sizeof(*iml));
+ if (!iml) {
+ err = -ENOMEM;
+ goto done;
+ }
+ iml->multi = *imr;
+
+ rtdm_mutex_lock(&mc_socklist_lock);
+ for (i = sk->prot.inet.mc_list; i; i = i->next)
+ if (i->multi.imr_multiaddr.s_addr == addr &&
+ i->multi.imr_interface.s_addr == imr->imr_interface.s_addr) {
+ rtdm_mutex_unlock(&mc_socklist_lock);
+ rtdm_free(iml);
+ err = 0;
+ goto done;
+ }
+
+ iml->next = sk->prot.inet.mc_list;
+ sk->prot.inet.mc_list = iml;
+ rtdm_mutex_unlock(&mc_socklist_lock);
+
+ rt_ip_mc_inc_group(rtdev, addr);
+
+ done:
+ rtdev_dereference(rtdev);
+ return err;
+}
+
+/*
+ * Ask a socket to leave a group.
+ */
+int rt_ip_mc_leave_group(struct rtsocket *sk, struct ip_mreq *imr)
+{
+ u32 addr = imr->imr_multiaddr.s_addr;
+ struct rtnet_device *rtdev = rt_ip_mc_find_dev(imr);
+ struct rtip_mc_socklist *i, **ip;
+
+ if (!rtdev)
+ return -ENODEV;
+
+ rtdm_mutex_lock(&mc_socklist_lock);
+ for (ip = &sk->prot.inet.mc_list; (i = *ip); ip = &i->next)
+ if (i->multi.imr_multiaddr.s_addr == addr &&
+ i->multi.imr_interface.s_addr == imr->imr_interface.s_addr) {
+ *ip = i->next;
+ rtdm_mutex_unlock(&mc_socklist_lock);
+ goto found;
+ }
+ rtdm_mutex_unlock(&mc_socklist_lock);
+
+ rtdev_dereference(rtdev);
+
+ return -EADDRNOTAVAIL;
+
+ found:
+ rt_igmp_send_report(rtdev, addr, IGMP_HOST_LEAVE_MESSAGE);
+ rt_ip_mc_dec_group(rtdev, addr);
+ rtdev_dereference(rtdev);
+
+ rtdm_free(i);
+
+ return 0;
+}
+
+/*
+ * A socket is closing.
+ */
+void rt_ip_mc_drop_socket(struct rtsocket *sk)
+{
+ struct rtip_mc_socklist *i, *in;
+
+ if (sk->prot.inet.mc_list == NULL)
+ return;
+
+ for (i = sk->prot.inet.mc_list; i; i = in) {
+ struct rtnet_device *rtdev;
+
+ in = i->next;
+ rtdev = rt_ip_mc_find_dev(&i->multi);
+ if (!rtdev)
+ continue;
+
+ rt_ip_mc_dec_group(rtdev, i->multi.imr_multiaddr.s_addr);
+ rtdev_dereference(rtdev);
+ }
+}
+
+static void process(void *arg)
+{
+ struct rtip_mc_list *im;
+ unsigned long flags;
+
+ while(!rtdm_task_should_stop()){
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (im = mc_list; im; im = im->next) {
+ if (im->state == RTIP_MC_DELAYING_MEMBER) {
+ im->state = RTIP_MC_IDLE_MEMBER;
+ im->users++;
+ rtdev_reference(im->interface);
+ break;
+ }
+ }
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ if (im) {
+ rt_igmp_send_report(im->interface,
+ im->multiaddr, IGMP_HOST_MEMBERSHIP_REPORT);
+ rt_ip_mc_dec_group(im->interface, im->multiaddr);
+ rtdev_dereference(im->interface);
+ }
+
+ rtdm_task_wait_period(NULL);
+ }
+}
+
+static int rt_igmp_socket(struct rtdm_fd *fd)
+{
+ /* we don't support user-created ICMP sockets */
+ return -ENOPROTOOPT;
+}
+
+static struct rtsocket *rt_igmp_dest_socket(struct rtskb *skb)
+{
+ /* Note that the socket's refcount is not used by this protocol.
+ * The socket returned here is static and not part of the global pool. */
+ return &igmp_socket;
+}
+
+void rt_igmp_rcv_err(struct rtskb *skb)
+{
+ rtdm_printk("RTnet: rt_igmp_rcv err\n");
+}
+
+static struct rtinet_protocol igmp_protocol = {
+ .protocol = IPPROTO_IGMP,
+ .dest_socket = rt_igmp_dest_socket,
+ .rcv_handler = rt_igmp_rcv,
+ .err_handler = rt_igmp_rcv_err,
+ .init_socket = rt_igmp_socket
+};
+
+static void rt_ip_mc_unregister(struct rtnet_device *rtdev)
+{
+ struct rtip_mc_list *i, **ip;
+ unsigned long flags;
+
+ if (rtdev->flags & IFF_LOOPBACK)
+ return;
+
+ restart:
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (ip = &mc_list; (i = *ip) != NULL; ip = &i->next) {
+ if (i->interface != rtdev)
+ continue;
+ *ip = i->next;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ igmp_group_dropped(i);
+ rtdm_free(i);
+ goto restart;
+ }
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+}
+
+static void rt_ip_mc_down(struct rtnet_device *rtdev)
+{
+ struct rtip_mc_list *i;
+ unsigned long flags;
+
+ if (rtdev->flags & IFF_LOOPBACK)
+ return;
+
+restart:
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (i = mc_list; i; i = i->next) {
+ if (i->interface != rtdev || i->state == RTIP_MC_NON_MEMBER)
+ continue;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ igmp_group_dropped(i);
+ goto restart;
+ }
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ rt_ip_mc_dec_group(rtdev, IGMP_ALL_HOSTS);
+}
+
+static void rt_ip_mc_up(struct rtnet_device *rtdev,
+ struct rtnet_core_cmd *up_cmd)
+{
+ struct rtip_mc_list *i;
+ unsigned long flags;
+
+ if (rtdev->flags & IFF_LOOPBACK)
+ return;
+
+ rt_ip_mc_inc_group(rtdev, IGMP_ALL_HOSTS);
+
+restart:
+ rtdm_lock_get_irqsave(&mc_list_lock, flags);
+ for (i = mc_list; i; i = i->next) {
+ if (i->interface != rtdev || i->state != RTIP_MC_NON_MEMBER)
+ continue;
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+
+ igmp_group_added(i);
+ goto restart;
+ }
+ rtdm_lock_put_irqrestore(&mc_list_lock, flags);
+}
+
+static struct rtdev_event_hook rtdev_hook = {
+ .unregister_device = rt_ip_mc_unregister,
+ .ifup = rt_ip_mc_up,
+ .ifdown = rt_ip_mc_down,
+};
+
+void __init rt_igmp_init(void)
+{
+ unsigned int skbs;
+
+ igmp_socket.protocol = IPPROTO_IGMP;
+ igmp_socket.prot.inet.tos = 0;
+ igmp_socket.priority = 0;
+ rtdm_lock_init(&mc_list_lock);
+ rtdm_mutex_init(&mc_socklist_lock);
+ /* create the rtskb pool */
+ skbs = rtskb_pool_init(&igmp_socket.skb_pool, IGMP_REPLY_POOL_SIZE,
+ NULL, NULL);
+ if (skbs < IGMP_REPLY_POOL_SIZE)
+ printk("RTnet: allocated only %d igmp rtskbs\n", skbs);
+
+ rt_inet_add_protocol(&igmp_protocol);
+ rtdm_task_init(&rtnet_igmp_task, "igmp", process, 0,
+ RTDM_TASK_LOWEST_PRIORITY, 10000000);
+ rtdev_add_event_hook(&rtdev_hook);
+}
+
+void rt_igmp_release(void)
+{
+ rtdev_del_event_hook(&rtdev_hook);
+ rtdm_task_destroy(&rtnet_igmp_task);
+ rt_inet_del_protocol(&igmp_protocol);
+ rtskb_pool_release(&igmp_socket.skb_pool);
+ rtdm_mutex_destroy(&mc_socklist_lock);
+}
diff --git a/kernel/drivers/net/stack/ipv4/ip_output.c b/kernel/drivers/net/stack/ipv4/ip_output.c
index 664d0c790..e1bba9213 100644
--- a/kernel/drivers/net/stack/ipv4/ip_output.c
+++ b/kernel/drivers/net/stack/ipv4/ip_output.c
@@ -30,10 +30,19 @@
#include <ipv4/ip_fragment.h>
#include <ipv4/ip_input.h>
#include <ipv4/route.h>
+#include <ipv4/igmp.h>
static DEFINE_RTDM_LOCK(rt_ip_id_lock);
static u16 rt_ip_id_count = 0;
+static inline u8 get_ttl(struct dest_route *rt)
+{
+ if (rtnet_in_multicast(ntohl(rt->ip)))
+ return 1;
+
+ return 255;
+}
+
/***
* Slow path for fragmented packets
*/
@@ -108,7 +117,7 @@ int rt_ip_build_xmit_slow(struct rtsocket *sk,
iph->tot_len = htons(fraglen);
iph->id = htons(msg_rt_ip_id);
iph->frag_off = htons(frag_off);
- iph->ttl = 255;
+ iph->ttl = get_ttl(rt);
iph->protocol = sk->protocol;
iph->saddr = rtdev->local_ip;
iph->daddr = rt->ip;
@@ -210,7 +219,7 @@ int rt_ip_build_xmit(struct rtsocket *sk,
iph->tot_len = htons(length);
iph->id = htons(msg_rt_ip_id);
iph->frag_off = htons(IP_DF);
- iph->ttl = 255;
+ iph->ttl = get_ttl(rt);
iph->protocol = sk->protocol;
iph->saddr = rtdev->local_ip;
iph->daddr = rt->ip;
diff --git a/kernel/drivers/net/stack/ipv4/ip_sock.c b/kernel/drivers/net/stack/ipv4/ip_sock.c
index 8ca6aebd1..0349ed1b1 100644
--- a/kernel/drivers/net/stack/ipv4/ip_sock.c
+++ b/kernel/drivers/net/stack/ipv4/ip_sock.c
@@ -27,9 +27,10 @@
#include <linux/in.h>
#include <rtnet_socket.h>
+#include <ipv4/igmp.h>
int rt_ip_setsockopt(struct rtdm_fd *fd, struct rtsocket *s, int level,
- int optname, const void __user *optval, socklen_t optlen)
+ int optname, const void __user *u_optval, socklen_t optlen)
{
int err = 0;
unsigned int _tos, *tos;
@@ -37,18 +38,77 @@ int rt_ip_setsockopt(struct rtdm_fd *fd, struct rtsocket *s, int level,
if (level != SOL_IP)
return -ENOPROTOOPT;
- if (optlen < sizeof(unsigned int))
- return -EINVAL;
-
switch (optname) {
case IP_TOS:
- tos = rtnet_get_arg(fd, &_tos, optval, sizeof(_tos));
+ if (optlen < sizeof(unsigned int))
+ return -EINVAL;
+ tos = rtnet_get_arg(fd, &_tos, u_optval, sizeof(_tos));
if (IS_ERR(tos))
return PTR_ERR(tos);
else
s->prot.inet.tos = *tos;
break;
+#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP
+ case IP_ADD_MEMBERSHIP: {
+ const struct ip_mreq *mreq;
+ struct ip_mreq _mreq;
+
+ if (optlen < sizeof(*mreq))
+ return -EINVAL;
+
+ if (!rtdm_in_rt_context())
+ return -ENOSYS;
+
+ mreq = rtnet_get_arg(fd, &_mreq, u_optval, sizeof(_mreq));
+ if (IS_ERR(mreq))
+ return PTR_ERR(mreq);
+
+ err = rt_ip_mc_join_group(s, mreq);
+ break;
+ }
+
+ case IP_DROP_MEMBERSHIP: {
+ const struct ip_mreq *mreq;
+ struct ip_mreq _mreq;
+
+ if (optlen < sizeof(*mreq))
+ return -EINVAL;
+
+ if (!rtdm_in_rt_context())
+ return -ENOSYS;
+
+ mreq = rtnet_get_arg(fd, &_mreq, u_optval, sizeof(_mreq));
+ if (IS_ERR(mreq))
+ return PTR_ERR(mreq);
+
+ err = rt_ip_mc_leave_group(s, mreq);
+ break;
+ }
+
+ case IP_MULTICAST_IF: {
+ if (optlen < sizeof(struct in_addr))
+ return -EINVAL;
+
+ if (optlen >= sizeof(struct ip_mreq)) {
+ const struct ip_mreq *mreq;
+ struct ip_mreq _mreq;
+ mreq = rtnet_get_arg(fd, &_mreq, u_optval, sizeof(_mreq));
+ if (IS_ERR(mreq))
+ return PTR_ERR(mreq);
+ s->prot.inet.mc_if_addr = mreq->imr_interface.s_addr;
+ } else {
+ const struct in_addr *in_addr;
+ struct in_addr _in_addr;
+ in_addr = rtnet_get_arg(fd, &_in_addr, u_optval, sizeof(_in_addr));
+ if (IS_ERR(in_addr))
+ return PTR_ERR(in_addr);
+ s->prot.inet.mc_if_addr = in_addr->s_addr;
+ }
+
+ break;
+ }
+#endif
default:
err = -ENOPROTOOPT;
break;
diff --git a/kernel/drivers/net/stack/ipv4/protocol.c b/kernel/drivers/net/stack/ipv4/protocol.c
index f56177da8..6036d6d74 100644
--- a/kernel/drivers/net/stack/ipv4/protocol.c
+++ b/kernel/drivers/net/stack/ipv4/protocol.c
@@ -28,6 +28,7 @@
#include <rtnet_socket.h>
#include <ipv4/protocol.h>
+#include <ipv4/igmp.h>
struct rtinet_protocol *rt_inet_protocols[MAX_RT_INET_PROTOCOLS];
@@ -62,6 +63,7 @@ EXPORT_SYMBOL_GPL(rt_inet_del_protocol);
*/
int rt_inet_socket(struct rtdm_fd *fd, int protocol)
{
+ struct rtsocket *sock = rtdm_fd_to_private(fd);
struct rtinet_protocol *prot;
if (protocol == 0)
@@ -74,6 +76,8 @@ int rt_inet_socket(struct rtdm_fd *fd, int protocol)
break;
}
+ sock->prot.inet.mc_list = NULL;
+ sock->prot.inet.mc_if_addr = INADDR_ANY;
prot = rt_inet_protocols[rt_inet_hashkey(protocol)];
/* create the socket (call the socket creator) */
@@ -86,3 +90,16 @@ int rt_inet_socket(struct rtdm_fd *fd, int protocol)
}
}
EXPORT_SYMBOL_GPL(rt_inet_socket);
+
+int rt_inet_socket_cleanup(struct rtdm_fd *fd)
+{
+#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP
+ struct rtsocket *sock = rtdm_fd_to_private(fd);
+ rt_ip_mc_drop_socket(sock);
+#endif
+
+ rt_socket_cleanup(fd);
+
+ return 0;
+}
+EXPORT_SYMBOL(rt_inet_socket_cleanup);
diff --git a/kernel/drivers/net/stack/ipv4/tcp/tcp.c b/kernel/drivers/net/stack/ipv4/tcp/tcp.c
index 71628ba03..79c25271c 100644
--- a/kernel/drivers/net/stack/ipv4/tcp/tcp.c
+++ b/kernel/drivers/net/stack/ipv4/tcp/tcp.c
@@ -1442,7 +1442,7 @@ static void rt_tcp_close(struct rtdm_fd *fd)
rt_tcp_socket_destruct(ts);
- rt_socket_cleanup(fd);
+ rt_inet_socket_cleanup(fd);
}
/***
diff --git a/kernel/drivers/net/stack/ipv4/udp/udp.c b/kernel/drivers/net/stack/ipv4/udp/udp.c
index 6fe1aeb12..dcaec5618 100644
--- a/kernel/drivers/net/stack/ipv4/udp/udp.c
+++ b/kernel/drivers/net/stack/ipv4/udp/udp.c
@@ -43,6 +43,8 @@
#include <ipv4/protocol.h>
#include <ipv4/route.h>
#include <ipv4/udp.h>
+#include <ipv4/arp.h>
+#include <ipv4/igmp.h>
/***
* This structure is used to register a UDP socket for reception. All
@@ -349,7 +351,7 @@ void rt_udp_close(struct rtdm_fd *fd)
while ((del = rtskb_dequeue(&sock->incoming)) != NULL)
kfree_rtskb(del);
- rt_socket_cleanup(fd);
+ rt_inet_socket_cleanup(fd);
}
int rt_udp_ioctl(struct rtdm_fd *fd, unsigned int request, void __user *arg)
@@ -567,6 +569,36 @@ static int rt_udp_getfrag(const void *p, unsigned char *to, unsigned int offset,
return 0;
}
+static int route_multicast(struct dest_route *rt,
+ struct rtsocket *sock,
+ u32 daddr, u32 *saddr)
+{
+ char buf[MAX_ADDR_LEN];
+
+ if (!rtnet_in_multicast(ntohl(daddr)))
+ return -ENOTSUPP;
+
+ if (sock->prot.inet.mc_if_addr != INADDR_ANY)
+ *saddr = sock->prot.inet.mc_if_addr;
+ else if (*saddr == INADDR_ANY)
+ return -EHOSTUNREACH;
+
+ rt->rtdev = rt_ip_dev_find(*saddr);
+ if (rt->rtdev == NULL)
+ return -EHOSTUNREACH;
+
+ if (rt_arp_mc_map(daddr, buf, rt->rtdev, 0)) {
+ rtdev_dereference(rt->rtdev);
+ rtdm_printk("can't map multicast adress %08x \n", daddr);
+ return -EHOSTUNREACH;
+ }
+
+ memcpy(rt->dev_addr, buf, sizeof(buf));
+ rt->ip = daddr;
+
+ return 0;
+}
+
/***
* rt_udp_sendmsg
*/
@@ -652,6 +684,8 @@ ssize_t rt_udp_sendmsg(struct rtdm_fd *fd, const struct user_msghdr *msg,
}
/* get output route */
+ err = route_multicast(&rt, sock, daddr, &saddr);
+ if (err == -ENOTSUPP)
err = rt_ip_route_output(&rt, daddr, saddr);
if (err)
goto out;
@@ -670,7 +704,8 @@ ssize_t rt_udp_sendmsg(struct rtdm_fd *fd, const struct user_msghdr *msg,
err = rt_ip_build_xmit(sock, rt_udp_getfrag, &ufh, ulen, &rt,
msg_flags);
- /* Drop the reference obtained in rt_ip_route_output() */
+ /* Drop the reference obtained in either rt_ip_route_output()
+ or route_multicast() */
rtdev_dereference(rt.rtdev);
out:
rtdm_drop_iovec(iov, iov_fast);
@@ -715,7 +750,7 @@ struct rtsocket *rt_udp_dest_socket(struct rtskb *skb)
csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
/* patch broadcast daddr */
- if (daddr == rtdev->broadcast_ip)
+ if (daddr == rtdev->broadcast_ip || rtnet_in_multicast(ntohl(daddr)))
daddr = rtdev->local_ip;
/* find the destination socket */
diff --git a/kernel/drivers/net/stack/rtdev.c b/kernel/drivers/net/stack/rtdev.c
index 13e979088..a78d5241f 100644
--- a/kernel/drivers/net/stack/rtdev.c
+++ b/kernel/drivers/net/stack/rtdev.c
@@ -913,6 +913,208 @@ int rtdev_xmit_proxy(struct rtskb *rtskb)
}
#endif /* CONFIG_XENO_DRIVERS_NET_ADDON_PROXY */
+#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP
+
+/* Find rtnet device by its local_ip adress */
+static inline struct rtnet_device * __rt_ip_dev_find(u32 addr){
+ int i;
+ struct rtnet_device *rtdev;
+
+ for (i = 0; i < MAX_RT_DEVICES; i++) {
+ rtdev = rtnet_devices[i];
+ if ((rtdev != NULL) && (rtdev->local_ip == addr)) {
+ return rtdev;
+ }
+ }
+ return NULL;
+}
+
+/***
+ * rtdev_get_by_hwaddr - find and lock a rtnetdevice by its local ip adress
+ * @addr: Local IP Adress
+ */
+struct rtnet_device *rt_ip_dev_find(u32 addr)
+{
+ struct rtnet_device * rtdev;
+ unsigned long flags;
+
+
+ rtdm_lock_get_irqsave(&rtnet_devices_rt_lock, flags);
+ rtdev = __rt_ip_dev_find(addr);
+ if (rtdev != NULL)
+ atomic_inc(&rtdev->refcount);
+ rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock, flags);
+
+ return rtdev;
+}
+EXPORT_SYMBOL(rt_ip_dev_find);
+
+/*
+ * Update the multicast list into the physical NIC controller.
+ */
+static void __rt_dev_mc_upload(struct rtnet_device *dev)
+{
+ /* Don't do anything till we up the interface
+ * [dev_open will call this function so the list will
+ * stay sane]
+ */
+
+ if (!(dev->flags&IFF_UP))
+ return;
+
+ /*
+ * Devices with no set multicast or which have been
+ * detached don't get set.
+ */
+
+ if (dev->set_multicast_list == NULL){
+ printk(KERN_INFO "RTnet: %s does not support multicast\n",
+ dev->name);
+ return;
+ }
+ dev->set_multicast_list(dev);
+}
+
+void rt_dev_mc_upload(struct rtnet_device *dev)
+{
+ unsigned long flags;
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+ __rt_dev_mc_upload(dev);
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+}
+
+/*
+ * Delete a device level multicast
+ */
+
+int rt_dev_mc_delete(struct rtnet_device *dev, void *addr, int alen, int glbl)
+{
+ int err = 0;
+ struct rtdev_mc_list *dmi, **dmip;
+ unsigned long flags;
+
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+
+ for (dmip = &dev->mc_list; (dmi = *dmip) != NULL; dmip = &dmi->next) {
+ /*
+ * Find the entry we want to delete. The device could
+ * have variable length entries so check these too.
+ */
+ if (memcmp(dmi->dmi_addr, addr, dmi->dmi_addrlen) == 0 &&
+ alen == dmi->dmi_addrlen) {
+ if (glbl) {
+ int old_glbl = dmi->dmi_gusers;
+ dmi->dmi_gusers = 0;
+ if (old_glbl == 0)
+ break;
+ }
+ if (--dmi->dmi_users)
+ goto done;
+
+ /*
+ * Last user. So delete the entry.
+ */
+ *dmip = dmi->next;
+ dev->mc_count--;
+
+ /*
+ * We have altered the list, so the card
+ * loaded filter is now wrong. Fix it
+ */
+ __rt_dev_mc_upload(dev);
+
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+
+ rtdm_free(dmi);
+ return 0;
+ }
+ }
+ err = -ENOENT;
+done:
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+ return err;
+}
+EXPORT_SYMBOL(rt_dev_mc_delete);
+
+/*
+ * Add a device level multicast
+ */
+
+
+int rt_dev_mc_add(struct rtnet_device *dev, void *addr, int alen, int glbl)
+{
+ int err = 0;
+ struct rtdev_mc_list *dmi, *dmi1;
+ unsigned long flags;
+
+ dmi1 = rtdm_malloc(sizeof(*dmi1));
+
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+ for (dmi = dev->mc_list; dmi != NULL; dmi = dmi->next) {
+ if (memcmp(dmi->dmi_addr, addr, dmi->dmi_addrlen) == 0 &&
+ dmi->dmi_addrlen == alen) {
+ if (glbl) {
+ int old_glbl = dmi->dmi_gusers;
+ dmi->dmi_gusers = 1;
+ if (old_glbl)
+ goto done;
+ }
+ dmi->dmi_users++;
+ goto done;
+ }
+ }
+
+ if ((dmi = dmi1) == NULL) {
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+ return -ENOMEM;
+ }
+ memcpy(dmi->dmi_addr, addr, alen);
+ dmi->dmi_addrlen = alen;
+ dmi->next = dev->mc_list;
+ dmi->dmi_users = 1;
+ dmi->dmi_gusers = glbl ? 1 : 0;
+ dev->mc_list = dmi;
+ dev->mc_count++;
+
+ __rt_dev_mc_upload(dev);
+
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+ return 0;
+
+done:
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+ if (dmi1)
+ rtdm_free(dmi1);
+ return err;
+}
+EXPORT_SYMBOL(rt_dev_mc_add);
+
+/*
+ * Discard multicast list when a device is downed
+ */
+
+void rt_dev_mc_discard(struct rtnet_device *dev)
+{
+ unsigned long flags;
+
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+
+ while (dev->mc_list != NULL) {
+ struct rtdev_mc_list *tmp = dev->mc_list;
+ dev->mc_list = tmp->next;
+ if (tmp->dmi_users > tmp->dmi_gusers)
+ printk("dev_mc_discard: multicast leakage! dmi_users=%d\n", tmp->dmi_users);
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+ rtdm_free(tmp);
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+ }
+ dev->mc_count = 0;
+
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+}
+
+#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP */
+
unsigned int rt_hard_mtu(struct rtnet_device *rtdev, unsigned int priority)
{
return rtdev->mtu;
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 04/31] utils/net: rtifconfig: display device name untruncated
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (2 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 03/31] net/stack: add multicast support Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 05/31] net/stack: add support for VLAN filtering Jean-Baptiste Trédez
` (28 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
utils/net/rtifconfig.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/utils/net/rtifconfig.c b/utils/net/rtifconfig.c
index 8117e127c..9a9abfc4c 100644
--- a/utils/net/rtifconfig.c
+++ b/utils/net/rtifconfig.c
@@ -183,7 +183,7 @@ void print_dev(void)
struct itf_stats *itf;
- cmd.head.if_name[9] = 0;
+ cmd.head.if_name[IFNAMSIZ - 1] = 0;
printf("%-9s Medium: ", cmd.head.if_name);
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 05/31] net/stack: add support for VLAN filtering
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (3 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 04/31] utils/net: rtifconfig: display device name untruncated Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 06/31] utils/net: add VLAN filter configuration tool Jean-Baptiste Trédez
` (27 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/addons/cap.c | 46 +-
kernel/drivers/net/stack/Kconfig | 8 +
kernel/drivers/net/stack/Makefile | 2 +
kernel/drivers/net/stack/include/rtdev.h | 19 +
kernel/drivers/net/stack/include/rtif_vlan.h | 105 +++
kernel/drivers/net/stack/include/rtnet_port.h | 6 +-
kernel/drivers/net/stack/include/rtskb.h | 1 +
kernel/drivers/net/stack/include/rtvlan.h | 25 +
kernel/drivers/net/stack/rtdev.c | 32 +-
kernel/drivers/net/stack/rtnet_chrdev.c | 8 +-
kernel/drivers/net/stack/rtnet_module.c | 5 +
kernel/drivers/net/stack/socket.c | 17 +-
kernel/drivers/net/stack/vlan.c | 725 ++++++++++++++++++
13 files changed, 969 insertions(+), 30 deletions(-)
create mode 100644 kernel/drivers/net/stack/include/rtif_vlan.h
create mode 100644 kernel/drivers/net/stack/include/rtvlan.h
create mode 100644 kernel/drivers/net/stack/vlan.c
diff --git a/kernel/drivers/net/addons/cap.c b/kernel/drivers/net/addons/cap.c
index 1e8644069..293fcc84b 100644
--- a/kernel/drivers/net/addons/cap.c
+++ b/kernel/drivers/net/addons/cap.c
@@ -57,8 +57,26 @@ static struct tap_device_t {
void rtcap_rx_hook(struct rtskb *rtskb)
{
+ int ifindex;
+ int active;
bool trigger = false;
+ if (rtskb->cap_flags & RTSKB_CAP_SHARED)
+ return;
+
+ ifindex = rtskb->rtdev->ifindex;
+ active = tap_device[ifindex].present & (TAP_DEV | RTMAC_TAP_DEV);
+
+ if ((active & TAP_DEV)
+ && !(tap_device[ifindex].tap_dev->flags & IFF_UP))
+ active &= ~TAP_DEV;
+ if ((active & RTMAC_TAP_DEV)
+ && !(tap_device[ifindex].rtmac_tap_dev->flags & IFF_UP))
+ active &= ~RTMAC_TAP_DEV;
+
+ if (active == 0)
+ return;
+
if ((rtskb->cap_comp_skb = rtskb_pool_dequeue(&cap_pool)) == 0) {
tap_device[rtskb->rtdev->ifindex].tap_dev_stats.rx_dropped++;
return;
@@ -73,6 +91,7 @@ void rtcap_rx_hook(struct rtskb *rtskb)
rtskb->cap_next = NULL;
rtskb->cap_flags |= RTSKB_CAP_SHARED;
+ rtskb->cap_dev = rtskb->rtdev;
if (trigger)
rtdm_nrtsig_pend(&cap_signal);
@@ -83,16 +102,24 @@ int rtcap_xmit_hook(struct rtskb *rtskb, struct rtnet_device *rtdev)
struct tap_device_t *tap_dev = &tap_device[rtskb->rtdev->ifindex];
rtdm_lockctx_t context;
bool trigger = false;
+ int active;
- if ((rtskb->cap_comp_skb = rtskb_pool_dequeue(&cap_pool)) == 0) {
+ active = tap_dev->present & XMIT_HOOK;
+ if (active && !(tap_dev->tap_dev->flags & IFF_UP))
+ active &= ~XMIT_HOOK;
+
+ if (!active
+ || (rtskb->cap_flags & RTSKB_CAP_SHARED)
+ || (rtskb->cap_comp_skb = rtskb_pool_dequeue(&cap_pool)) == 0) {
tap_dev->tap_dev_stats.rx_dropped++;
- return tap_dev->orig_xmit(rtskb, rtdev);
+ goto done;
}
rtskb->cap_next = NULL;
rtskb->cap_start = rtskb->data;
rtskb->cap_len = rtskb->len;
rtskb->cap_flags |= RTSKB_CAP_SHARED;
+ rtskb->cap_dev = rtdev;
rtskb->time_stamp = rtdm_clock_read();
@@ -109,7 +136,7 @@ int rtcap_xmit_hook(struct rtskb *rtskb, struct rtnet_device *rtdev)
if (trigger)
rtdm_nrtsig_pend(&cap_signal);
-
+done:
return tap_dev->orig_xmit(rtskb, rtdev);
}
@@ -181,7 +208,7 @@ static void rtcap_signal_handler(rtdm_nrtsig_t *nrtsig, void *arg)
rtdm_lock_put_irqrestore(&rtcap_lock, context);
- ifindex = rtskb->rtdev->ifindex;
+ ifindex = rtskb->cap_dev->ifindex;
active = tap_device[ifindex].present;
if (active) {
@@ -340,6 +367,7 @@ void cleanup_tap_devices(void)
unregister_netdev(tap_device[i].tap_dev);
free_netdev(tap_device[i].tap_dev);
+ tap_device[i].present = 0;
}
}
@@ -481,19 +509,21 @@ void rtcap_cleanup(void)
{
rtdm_lockctx_t context;
- rtdm_nrtsig_destroy(&cap_signal);
-
/* unregister capturing handlers
* (take lock to avoid any unloading code before handler was left) */
rtdm_lock_get_irqsave(&rtcap_lock, context);
rtcap_handler = NULL;
rtdm_lock_put_irqrestore(&rtcap_lock, context);
+ cleanup_tap_devices();
+
+ msleep(10);
+
+ rtdm_nrtsig_destroy(&cap_signal);
+
/* empty queue (should be already empty) */
rtcap_signal_handler(0, NULL /* we ignore them anyway */);
- cleanup_tap_devices();
-
rtskb_pool_release(&cap_pool);
printk("RTcap: unloaded\n");
diff --git a/kernel/drivers/net/stack/Kconfig b/kernel/drivers/net/stack/Kconfig
index 996536cc5..02a1c62c1 100644
--- a/kernel/drivers/net/stack/Kconfig
+++ b/kernel/drivers/net/stack/Kconfig
@@ -31,6 +31,14 @@ config XENO_DRIVERS_NET_RTWLAN
on low-level access to 802.11-compliant adapters and is currently
in an experimental stage.
+config XENO_DRIVERS_NET_VLAN
+ depends on XENO_DRIVERS_NET
+ select VLAN_8021Q
+ bool "Real-Time VLAN"
+ select XENO_DRIVERS_NET_RTIPV4_IGMP
+ ---help---
+ Enables core support for real-time VLAN.
+
comment "Protocols"
source "drivers/xenomai/net/stack/ipv4/Kconfig"
diff --git a/kernel/drivers/net/stack/Makefile b/kernel/drivers/net/stack/Makefile
index f75483e02..1e2b3ed36 100644
--- a/kernel/drivers/net/stack/Makefile
+++ b/kernel/drivers/net/stack/Makefile
@@ -24,3 +24,5 @@ rtnet-y := \
eth.o
rtnet-$(CONFIG_XENO_DRIVERS_NET_RTWLAN) += rtwlan.o
+
+rtnet-$(CONFIG_XENO_DRIVERS_NET_VLAN) += vlan.o
diff --git a/kernel/drivers/net/stack/include/rtdev.h b/kernel/drivers/net/stack/include/rtdev.h
index e5a6bf920..27c390df5 100644
--- a/kernel/drivers/net/stack/include/rtdev.h
+++ b/kernel/drivers/net/stack/include/rtdev.h
@@ -153,6 +153,13 @@ struct rtnet_device {
int (*hard_start_xmit)(struct rtskb *skb, struct rtnet_device *dev);
int (*hw_reset)(struct rtnet_device *rtdev);
void (*set_multicast_list) (struct rtnet_device *rtdev);
+ void (*vlan_rx_add_vid)(struct rtnet_device *dev,
+ unsigned short vid);
+ void (*vlan_rx_kill_vid)(struct rtnet_device *dev,
+ unsigned short vid);
+#ifdef CONFIG_XENO_DRIVERS_NET_VLAN
+ struct list_head vlan_link;
+#endif
/* Transmission hook, managed by the stack core, RTcap, and RTmac
*
@@ -188,6 +195,18 @@ extern struct list_head event_hook_list;
extern struct mutex rtnet_devices_nrt_lock;
extern struct rtnet_device *rtnet_devices[];
+#ifdef CONFIG_XENO_DRIVERS_NET_VLAN
+extern struct rtnet_device *
+__rtdev_real_dev(struct rtnet_device *dev) __attribute__((pure));
+#else
+static inline struct rtnet_device *__rtdev_real_dev(struct rtnet_device *dev)
+{
+ return dev;
+}
+#endif
+#define rtdev_mc_list(dev) __rtdev_real_dev(dev)->mc_list
+#define rtdev_mc_count(dev) __rtdev_real_dev(dev)->mc_count
+
int __rt_init_etherdev(struct rtnet_device *rtdev, unsigned int dev_pool_size,
struct module *module);
diff --git a/kernel/drivers/net/stack/include/rtif_vlan.h b/kernel/drivers/net/stack/include/rtif_vlan.h
new file mode 100644
index 000000000..d1cc9fa4b
--- /dev/null
+++ b/kernel/drivers/net/stack/include/rtif_vlan.h
@@ -0,0 +1,105 @@
+/*
+ * VLAN An implementation of 802.1Q VLAN tagging.
+ *
+ * Authors: Ben Greear <greearb@candelatech.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ */
+#ifndef _RTNET_IF_VLAN_H_
+#define _RTNET_IF_VLAN_H_
+
+#include <rtdev.h>
+#include <rtskb.h>
+#include <uapi/linux/if_vlan.h>
+#include <linux/if_vlan.h>
+
+/* found in socket.c */
+extern void rtvlan_ioctl_set(int (*hook)(struct net *, void __user *));
+
+static inline bool is_rtvlan_dev(struct rtnet_device *dev)
+{
+ return !!(dev->priv_flags & IFF_802_1Q_VLAN);
+}
+
+struct rtvlan_pcpu_stats {
+ u64 rx_packets;
+ u64 rx_bytes;
+ u64 rx_multicast;
+ u64 tx_packets;
+ u64 tx_bytes;
+ seqcount_t syncp;
+ u32 rx_errors;
+ u32 tx_dropped;
+};
+
+struct rtvlan_dev_priv {
+ unsigned int nr_ingress_mappings;
+ u32 ingress_priority_map[8];
+ unsigned int nr_egress_mappings;
+ struct vlan_priority_tci_mapping *egress_priority_map[16];
+
+ __be16 vlan_proto;
+ u16 vlan_id;
+ u16 flags;
+
+ struct rtnet_device *real_dev;
+ unsigned char real_dev_addr[ETH_ALEN];
+
+ struct rtvlan_pcpu_stats __percpu *vlan_pcpu_stats;
+ struct net_device_stats stats;
+ unsigned int nest_level;
+};
+
+static inline struct rtvlan_dev_priv *rtvlan_dev_priv(const struct rtnet_device *dev)
+{
+ return dev->priv;
+}
+
+static inline u16
+rtvlan_dev_get_egress_qos_mask(struct rtnet_device *dev, u32 skprio)
+{
+ struct vlan_priority_tci_mapping *mp;
+
+ smp_rmb(); /* coupled with smp_wmb() in rtvlan_dev_set_egress_priority() */
+
+ mp = rtvlan_dev_priv(dev)->egress_priority_map[(skprio & 0xF)];
+ while (mp) {
+ if (mp->priority == skprio) {
+ return mp->vlan_qos; /* This should already be shifted
+ * to mask correctly with the
+ * VLAN's TCI */
+ }
+ mp = mp->next;
+ }
+ return 0;
+}
+
+static inline void
+rtvlan_insert_tag(struct rtskb *skb, __be16 vlan_proto, u16 vlan_tci)
+{
+ struct vlan_ethhdr *veth;
+
+ veth = (struct vlan_ethhdr *)rtskb_push(skb, VLAN_HLEN);
+
+ /* Move the mac addresses to the beginning of the new header. */
+ memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
+
+ /* first, the ethernet type */
+ veth->h_vlan_proto = vlan_proto;
+
+ /* now, the TCI */
+ veth->h_vlan_TCI = htons(vlan_tci);
+}
+
+static inline void
+rtvlan_put_tag(struct rtskb *skb, __be16 vlan_proto, u16 vlan_tci)
+{
+ rtvlan_insert_tag(skb, vlan_proto, vlan_tci);
+ skb->protocol = vlan_proto;
+}
+
+#endif /* !(_RTNET_IF_VLAN_H_) */
diff --git a/kernel/drivers/net/stack/include/rtnet_port.h b/kernel/drivers/net/stack/include/rtnet_port.h
index 5342cc621..570cea27c 100644
--- a/kernel/drivers/net/stack/include/rtnet_port.h
+++ b/kernel/drivers/net/stack/include/rtnet_port.h
@@ -58,12 +58,12 @@ static inline int rtnetif_queue_stopped(struct rtnet_device *rtdev)
static inline int rtnetif_running(struct rtnet_device *rtdev)
{
- return test_bit(__RTNET_LINK_STATE_START, &rtdev->link_state);
+ return test_bit(__RTNET_LINK_STATE_START, &__rtdev_real_dev(rtdev)->link_state);
}
static inline int rtnetif_device_present(struct rtnet_device *rtdev)
{
- return test_bit(__RTNET_LINK_STATE_PRESENT, &rtdev->link_state);
+ return test_bit(__RTNET_LINK_STATE_PRESENT, &__rtdev_real_dev(rtdev)->link_state);
}
static inline void rtnetif_device_detach(struct rtnet_device *rtdev)
@@ -100,7 +100,7 @@ static inline void rtnetif_carrier_off(struct rtnet_device *rtdev)
static inline int rtnetif_carrier_ok(struct rtnet_device *rtdev)
{
- return !test_bit(__RTNET_LINK_STATE_NOCARRIER, &rtdev->link_state);
+ return !test_bit(__RTNET_LINK_STATE_NOCARRIER, &__rtdev_real_dev(rtdev)->link_state);
}
#define NIPQUAD(addr) \
diff --git a/kernel/drivers/net/stack/include/rtskb.h b/kernel/drivers/net/stack/include/rtskb.h
index 4277fa6c6..4920b3916 100644
--- a/kernel/drivers/net/stack/include/rtskb.h
+++ b/kernel/drivers/net/stack/include/rtskb.h
@@ -219,6 +219,7 @@ struct rtskb {
unsigned char *cap_start; /* start offset for capturing */
unsigned int cap_len; /* capture length of this rtskb */
nanosecs_abs_t cap_rtmac_stamp; /* RTmac enqueuing time */
+ struct rtnet_device *cap_dev; /* Captured interface */
#endif
struct list_head entry; /* for global rtskb list */
diff --git a/kernel/drivers/net/stack/include/rtvlan.h b/kernel/drivers/net/stack/include/rtvlan.h
new file mode 100644
index 000000000..a6fd3df91
--- /dev/null
+++ b/kernel/drivers/net/stack/include/rtvlan.h
@@ -0,0 +1,25 @@
+#ifndef RTNET_RTVLAN_H
+#define RTNET_RTVLAN_H
+
+#ifdef CONFIG_XENO_DRIVERS_NET_VLAN
+void rtvlan_proto_init(void);
+
+void rtvlan_proto_release(void);
+
+int rtvlan_ioctl_handler(void __user *arg);
+#else
+static inline void rtvlan_proto_init(void)
+{
+}
+
+static inline void rtvlan_proto_release(void)
+{
+}
+
+static inline int rtvlan_ioctl_handler(void __user *arg)
+{
+ return -ENOSYS;
+}
+#endif
+
+#endif /* RTNET_RTVLAN_H */
diff --git a/kernel/drivers/net/stack/rtdev.c b/kernel/drivers/net/stack/rtdev.c
index a78d5241f..14675abf5 100644
--- a/kernel/drivers/net/stack/rtdev.c
+++ b/kernel/drivers/net/stack/rtdev.c
@@ -329,6 +329,9 @@ static void init_etherdev(struct rtnet_device *rtdev, struct module *module)
rtdev->flags = IFF_BROADCAST; /* TODO: IFF_MULTICAST; */
rtdev->get_mtu = rt_hard_mtu;
rtdev->rt_owner = module;
+#ifdef CONFIG_XENO_DRIVERS_NET_VLAN
+ INIT_LIST_HEAD(&rtdev->vlan_link);
+#endif
memset(rtdev->broadcast, 0xFF, ETH_ALEN);
strcpy(rtdev->name, "rteth%d");
@@ -525,6 +528,15 @@ int rt_register_rtnetdev(struct rtnet_device *rtdev)
if (rtdev->vers < RTDEV_VERS_2_0)
return -EINVAL;
+#ifdef CONFIG_XENO_DRIVERS_NET_VLAN
+ if ((rtdev->features & NETIF_F_HW_VLAN_CTAG_FILTER) &&
+ (!rtdev->vlan_rx_add_vid || !rtdev->vlan_rx_kill_vid)) {
+ printk("RTnet: %s has VLAN hardware filtering but does not provide "
+ "callbacks\n", rtdev->name);
+ return -EINVAL;
+ }
+#endif
+
if (rtdev->features & NETIF_F_LLTX)
rtdev->start_xmit = rtdev->hard_start_xmit;
else
@@ -995,7 +1007,7 @@ int rt_dev_mc_delete(struct rtnet_device *dev, void *addr, int alen, int glbl)
rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
- for (dmip = &dev->mc_list; (dmi = *dmip) != NULL; dmip = &dmi->next) {
+ for (dmip = &rtdev_mc_list(dev); (dmi = *dmip) != NULL; dmip = &dmi->next) {
/*
* Find the entry we want to delete. The device could
* have variable length entries so check these too.
@@ -1015,7 +1027,7 @@ int rt_dev_mc_delete(struct rtnet_device *dev, void *addr, int alen, int glbl)
* Last user. So delete the entry.
*/
*dmip = dmi->next;
- dev->mc_count--;
+ rtdev_mc_count(dev)--;
/*
* We have altered the list, so the card
@@ -1050,7 +1062,7 @@ int rt_dev_mc_add(struct rtnet_device *dev, void *addr, int alen, int glbl)
dmi1 = rtdm_malloc(sizeof(*dmi1));
rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
- for (dmi = dev->mc_list; dmi != NULL; dmi = dmi->next) {
+ for (dmi = rtdev_mc_list(dev); dmi != NULL; dmi = dmi->next) {
if (memcmp(dmi->dmi_addr, addr, dmi->dmi_addrlen) == 0 &&
dmi->dmi_addrlen == alen) {
if (glbl) {
@@ -1070,11 +1082,11 @@ int rt_dev_mc_add(struct rtnet_device *dev, void *addr, int alen, int glbl)
}
memcpy(dmi->dmi_addr, addr, alen);
dmi->dmi_addrlen = alen;
- dmi->next = dev->mc_list;
+ dmi->next = rtdev_mc_list(dev);
dmi->dmi_users = 1;
dmi->dmi_gusers = glbl ? 1 : 0;
- dev->mc_list = dmi;
- dev->mc_count++;
+ rtdev_mc_list(dev) = dmi;
+ rtdev_mc_count(dev)++;
__rt_dev_mc_upload(dev);
@@ -1099,16 +1111,16 @@ void rt_dev_mc_discard(struct rtnet_device *dev)
rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
- while (dev->mc_list != NULL) {
- struct rtdev_mc_list *tmp = dev->mc_list;
- dev->mc_list = tmp->next;
+ while (rtdev_mc_list(dev) != NULL) {
+ struct rtdev_mc_list *tmp = rtdev_mc_list(dev);
+ rtdev_mc_list(dev) = tmp->next;
if (tmp->dmi_users > tmp->dmi_gusers)
printk("dev_mc_discard: multicast leakage! dmi_users=%d\n", tmp->dmi_users);
rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
rtdm_free(tmp);
rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
}
- dev->mc_count = 0;
+ rtdev_mc_count(dev) = 0;
rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
}
diff --git a/kernel/drivers/net/stack/rtnet_chrdev.c b/kernel/drivers/net/stack/rtnet_chrdev.c
index 9457661a1..782be5728 100644
--- a/kernel/drivers/net/stack/rtnet_chrdev.c
+++ b/kernel/drivers/net/stack/rtnet_chrdev.c
@@ -30,6 +30,7 @@
#include <linux/netdevice.h>
#include <linux/spinlock.h>
+#include <rtnet_port.h>
#include <rtnet_chrdev.h>
#include <rtnet_internal.h>
#include <ipv4/route.h>
@@ -125,10 +126,9 @@ static int rtnet_core_ioctl(struct rtnet_device *rtdev, unsigned int request,
cmd.args.info.broadcast_ip = rtdev->broadcast_ip;
cmd.args.info.mtu = rtdev->mtu;
cmd.args.info.flags = rtdev->flags;
- if ((cmd.args.info.flags & IFF_UP) &&
- (rtdev->link_state &
- (RTNET_LINK_STATE_PRESENT | RTNET_LINK_STATE_NOCARRIER)) ==
- RTNET_LINK_STATE_PRESENT)
+ if ((cmd.args.info.flags & IFF_UP)
+ && rtnetif_carrier_ok(rtdev)
+ && rtnetif_device_present(rtdev))
cmd.args.info.flags |= IFF_RUNNING;
memcpy(cmd.args.info.dev_addr, rtdev->dev_addr, MAX_ADDR_LEN);
diff --git a/kernel/drivers/net/stack/rtnet_module.c b/kernel/drivers/net/stack/rtnet_module.c
index 16dc91fda..87addd303 100644
--- a/kernel/drivers/net/stack/rtnet_module.c
+++ b/kernel/drivers/net/stack/rtnet_module.c
@@ -34,6 +34,7 @@
#include <rtnet_rtpc.h>
#include <stack_mgr.h>
#include <rtwlan.h>
+#include <rtvlan.h>
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("RTnet stack core");
@@ -352,6 +353,8 @@ int __init rtnet_init(void)
if ((err = rtpc_init()) != 0)
goto err_out6;
+ rtvlan_proto_init();
+
rtnet_corectl_register();
return 0;
@@ -387,6 +390,8 @@ void __exit rtnet_release(void)
{
rtnet_corectl_unregister();
+ rtvlan_proto_release();
+
rtpc_cleanup();
rtwlan_exit();
diff --git a/kernel/drivers/net/stack/socket.c b/kernel/drivers/net/stack/socket.c
index f030663be..cd118439b 100644
--- a/kernel/drivers/net/stack/socket.c
+++ b/kernel/drivers/net/stack/socket.c
@@ -36,6 +36,8 @@
#include <rtnet_internal.h>
#include <rtnet_iovec.h>
#include <rtnet_socket.h>
+#include <rtvlan.h>
+#include <rtnet_port.h>
#include <ipv4/protocol.h>
#define SKB_POOL_CLOSED 0
@@ -231,7 +233,8 @@ int rt_socket_if_ioctl(struct rtdm_fd *fd, int request, void __user *arg)
int ret = 0, size = 0, i;
short flags;
- if (request == SIOCGIFCONF) {
+ switch (request) {
+ case SIOCGIFCONF: {
u_ifc = arg;
ifc = rtnet_get_arg(fd, &_ifc, u_ifc, sizeof(_ifc));
if (IS_ERR(ifc))
@@ -273,6 +276,11 @@ int rt_socket_if_ioctl(struct rtdm_fd *fd, int request, void __user *arg)
return rtnet_put_arg(fd, &u_ifc->ifc_len, &size, sizeof(size));
}
+ case SIOCSIFVLAN:
+ return rtvlan_ioctl_handler(arg);
+ }
+
+
u_ifr = arg;
ifr = rtnet_get_arg(fd, &_ifr, u_ifr, sizeof(_ifr));
if (IS_ERR(ifr))
@@ -298,10 +306,9 @@ int rt_socket_if_ioctl(struct rtdm_fd *fd, int request, void __user *arg)
case SIOCGIFFLAGS:
flags = rtdev->flags;
- if ((ifr->ifr_flags & IFF_UP) &&
- (rtdev->link_state &
- (RTNET_LINK_STATE_PRESENT | RTNET_LINK_STATE_NOCARRIER)) ==
- RTNET_LINK_STATE_PRESENT)
+ if ((ifr->ifr_flags & IFF_UP)
+ && rtnetif_carrier_ok(rtdev)
+ && rtnetif_device_present(rtdev))
flags |= IFF_RUNNING;
ret = rtnet_put_arg(fd, &u_ifr->ifr_flags, &flags,
sizeof(u_ifr->ifr_flags));
diff --git a/kernel/drivers/net/stack/vlan.c b/kernel/drivers/net/stack/vlan.c
new file mode 100644
index 000000000..7e8c389a4
--- /dev/null
+++ b/kernel/drivers/net/stack/vlan.c
@@ -0,0 +1,725 @@
+/*
+ * INET 802.1Q VLAN
+ * Ethernet-type device handling.
+ *
+ * Authors: Ben Greear <greearb@candelatech.com>
+ * Please send support related email to: netdev@vger.kernel.org
+ * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
+ *
+ * Fixes:
+ * Fix for packet capture - Nick Eggleston <nick@dccinc.com>;
+ * Add HW acceleration hooks - David S. Miller <davem@redhat.com>;
+ * Correct all the locking - David S. Miller <davem@redhat.com>;
+ * Use hash table for VLAN groups - David S. Miller <davem@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include <rtdev.h>
+#include <rtnet_port.h>
+#include <rtif_vlan.h>
+
+static unsigned short rtvlan_name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
+
+struct rtnet_device *__rtdev_real_dev(struct rtnet_device *dev)
+{
+ if (is_rtvlan_dev(dev))
+ dev = rtvlan_dev_priv(dev)->real_dev;
+
+ return dev;
+}
+EXPORT_SYMBOL_GPL(__rtdev_real_dev);
+
+static inline u16 rtvlan_dev_vlan_id(const struct rtnet_device *dev)
+{
+ return rtvlan_dev_priv(dev)->vlan_id;
+}
+
+static void vlan_dev_set_rx_mode(struct rtnet_device *vlan_dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(vlan_dev);
+ struct rtnet_device *real_dev = vlan->real_dev;
+
+ rt_dev_mc_upload(real_dev);
+}
+
+/*
+ * Create the VLAN header for an arbitrary protocol layer
+ *
+ * saddr=NULL means use device source address
+ * daddr=NULL means leave destination address (eg unresolved arp)
+ *
+ * This is called when the SKB is moving down the stack towards the
+ * physical devices.
+ */
+static int vlan_dev_hard_header(struct rtskb *skb, struct rtnet_device *dev,
+ unsigned short type,
+ void *daddr, void *saddr,
+ unsigned int len)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct vlan_hdr *vhdr;
+ unsigned int vhdrlen = 0;
+ u16 vlan_tci = 0;
+ int rc;
+
+ if (!(vlan->flags & VLAN_FLAG_REORDER_HDR)) {
+ vhdr = (struct vlan_hdr *) rtskb_push(skb, VLAN_HLEN);
+
+ vlan_tci = vlan->vlan_id;
+ vlan_tci |= rtvlan_dev_get_egress_qos_mask(dev, skb->priority);
+ vhdr->h_vlan_TCI = htons(vlan_tci);
+
+ /*
+ * Set the protocol type. For a packet of type ETH_P_802_3/2 we
+ * put the length in here instead.
+ */
+ if (type != ETH_P_802_3 && type != ETH_P_802_2)
+ vhdr->h_vlan_encapsulated_proto = htons(type);
+ else
+ vhdr->h_vlan_encapsulated_proto = htons(len);
+
+ skb->protocol = vlan->vlan_proto;
+ type = ntohs(vlan->vlan_proto);
+ vhdrlen = VLAN_HLEN;
+ }
+
+ /* Before delegating work to the lower layer, enter our MAC-address */
+ if (saddr == NULL)
+ saddr = dev->dev_addr;
+
+ /* Now make the underlying real hard header */
+ dev = vlan->real_dev;
+ rc = dev->hard_header(skb, dev, type, daddr, saddr, len + vhdrlen);
+ if (rc > 0)
+ rc += vhdrlen;
+ return rc;
+}
+
+static netdev_tx_t vlan_dev_hard_start_xmit(struct rtskb *skb,
+ struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->data;
+ struct rtnet_device *real_dev = vlan->real_dev;
+ unsigned int len;
+ int ret;
+
+ /* Handle non-VLAN frames if they are sent to us, for example by DHCP.
+ *
+ * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING
+ * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs...
+ */
+ if (veth->h_vlan_proto != vlan->vlan_proto ||
+ (vlan->flags & VLAN_FLAG_REORDER_HDR)) {
+ u16 vlan_tci;
+ vlan_tci = vlan->vlan_id;
+ vlan_tci |= rtvlan_dev_get_egress_qos_mask(dev, skb->priority);
+ rtvlan_put_tag(skb, vlan->vlan_proto, vlan_tci);
+ }
+
+ skb->rtdev = real_dev;
+ len = skb->len;
+
+ ret = real_dev->start_xmit(skb, real_dev);
+
+ if (likely(ret == 0)) {
+ struct rtvlan_pcpu_stats *stats;
+
+ stats = this_cpu_ptr(vlan->vlan_pcpu_stats);
+ raw_write_seqcount_begin(&stats->syncp);
+ stats->tx_packets++;
+ stats->tx_bytes += len;
+ raw_write_seqcount_end(&stats->syncp);
+ } else {
+ this_cpu_inc(vlan->vlan_pcpu_stats->tx_dropped);
+ }
+
+ return ret;
+}
+
+void vlan_dev_set_ingress_priority(const struct rtnet_device *dev,
+ u32 skb_prio, u16 vlan_prio)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+
+ if (vlan->ingress_priority_map[vlan_prio & 0x7] && !skb_prio)
+ vlan->nr_ingress_mappings--;
+ else if (!vlan->ingress_priority_map[vlan_prio & 0x7] && skb_prio)
+ vlan->nr_ingress_mappings++;
+
+ vlan->ingress_priority_map[vlan_prio & 0x7] = skb_prio;
+}
+
+int vlan_dev_set_egress_priority(const struct rtnet_device *dev,
+ u32 skb_prio, u16 vlan_prio)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct vlan_priority_tci_mapping *mp = NULL;
+ struct vlan_priority_tci_mapping *np;
+ u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK;
+
+ /* See if a priority mapping exists.. */
+ mp = vlan->egress_priority_map[skb_prio & 0xF];
+ while (mp) {
+ if (mp->priority == skb_prio) {
+ if (mp->vlan_qos && !vlan_qos)
+ vlan->nr_egress_mappings--;
+ else if (!mp->vlan_qos && vlan_qos)
+ vlan->nr_egress_mappings++;
+ mp->vlan_qos = vlan_qos;
+ return 0;
+ }
+ mp = mp->next;
+ }
+
+ /* Create a new mapping then. */
+ mp = vlan->egress_priority_map[skb_prio & 0xF];
+ np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL);
+ if (!np)
+ return -ENOBUFS;
+
+ np->next = mp;
+ np->priority = skb_prio;
+ np->vlan_qos = vlan_qos;
+ /* Before inserting this element in hash table, make sure all its fields
+ * are committed to memory.
+ * coupled with smp_rmb() in vlan_dev_get_egress_qos_mask()
+ */
+ smp_wmb();
+ vlan->egress_priority_map[skb_prio & 0xF] = np;
+ if (vlan_qos)
+ vlan->nr_egress_mappings++;
+ return 0;
+}
+
+static inline u32 vlan_get_ingress_priority(struct rtnet_device *dev,
+ u16 vlan_tci)
+{
+ struct rtvlan_dev_priv *vip = rtvlan_dev_priv(dev);
+
+ return vip->ingress_priority_map[(vlan_tci >> VLAN_PRIO_SHIFT) & 0x7];
+}
+
+/* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */
+static int
+vlan_dev_change_flags(const struct rtnet_device *dev, u32 flags, u32 mask)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ u32 old_flags = vlan->flags;
+
+ if (mask & ~(VLAN_FLAG_REORDER_HDR | VLAN_FLAG_LOOSE_BINDING))
+ return -EINVAL;
+
+ vlan->flags = (old_flags & ~mask) | (flags & mask);
+
+ return 0;
+}
+
+static void
+vlan_dev_get_realdev_name(const struct rtnet_device *dev, char *result)
+{
+ strncpy(result, rtvlan_dev_priv(dev)->real_dev->name, 23);
+}
+
+static int vlan_dev_open(struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct rtnet_device *real_dev = vlan->real_dev;
+
+ if (!(real_dev->flags & IFF_UP) &&
+ !(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
+ return -ENETDOWN;
+
+ ether_addr_copy(vlan->real_dev_addr, real_dev->dev_addr);
+
+ vlan_dev_set_rx_mode(dev);
+
+ if (rtnetif_carrier_ok(real_dev))
+ rtnetif_carrier_on(dev);
+ return 0;
+}
+
+static int vlan_dev_stop(struct rtnet_device *dev)
+{
+ rtnetif_carrier_off(dev);
+ return 0;
+}
+
+static struct net_device_stats *vlan_dev_get_stats(struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct net_device_stats *stats = &vlan->stats;
+
+ memset(stats, '\0', sizeof(*stats));
+
+ if (rtvlan_dev_priv(dev)->vlan_pcpu_stats) {
+ struct rtvlan_pcpu_stats *p;
+ u32 rx_errors = 0, tx_dropped = 0;
+ int i;
+
+ for_each_possible_cpu(i) {
+ u64 rxpackets, rxbytes, rxmulticast, txpackets, txbytes;
+ unsigned int start;
+
+ p = per_cpu_ptr(rtvlan_dev_priv(dev)->vlan_pcpu_stats, i);
+ do {
+ start = raw_seqcount_begin(&p->syncp);
+ rxpackets = p->rx_packets;
+ rxbytes = p->rx_bytes;
+ rxmulticast = p->rx_multicast;
+ txpackets = p->tx_packets;
+ txbytes = p->tx_bytes;
+ } while (read_seqcount_retry(&p->syncp, start));
+
+ stats->rx_packets += rxpackets;
+ stats->rx_bytes += rxbytes;
+ stats->multicast += rxmulticast;
+ stats->tx_packets += txpackets;
+ stats->tx_bytes += txbytes;
+ /* rx_errors & tx_dropped are u32 */
+ rx_errors += p->rx_errors;
+ tx_dropped += p->tx_dropped;
+ }
+ stats->rx_errors = rx_errors;
+ stats->tx_dropped = tx_dropped;
+ }
+ return stats;
+}
+
+static int vlan_dev_init(struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct rtnet_device *real_dev = vlan->real_dev;
+ int i;
+
+ rtnetif_carrier_off(dev);
+
+ /* IFF_BROADCAST|IFF_MULTICAST; ??? */
+ dev->flags = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI
+ | IFF_MASTER | IFF_SLAVE);
+ dev->link_state =
+ (real_dev->link_state & (1<<__RTNET_LINK_STATE_NOCARRIER)) |
+ (1<<__RTNET_LINK_STATE_PRESENT);
+
+ dev->features = NETIF_F_LLTX;
+
+ if (is_zero_ether_addr(dev->dev_addr))
+ ether_addr_copy(dev->dev_addr, real_dev->dev_addr);;
+ if (is_zero_ether_addr(dev->broadcast))
+ memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len);
+
+ dev->open = vlan_dev_open;
+ dev->stop = vlan_dev_stop;
+ dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;
+ dev->hard_header = vlan_dev_hard_header;
+ dev->hard_start_xmit = vlan_dev_hard_start_xmit;
+ dev->get_stats = vlan_dev_get_stats;
+ if (real_dev->set_multicast_list)
+ dev->set_multicast_list = vlan_dev_set_rx_mode;
+
+ vlan->vlan_pcpu_stats = alloc_percpu(typeof(*vlan->vlan_pcpu_stats));
+ if (!rtvlan_dev_priv(dev)->vlan_pcpu_stats)
+ return -ENOMEM;
+
+ for_each_possible_cpu(i) {
+ struct rtvlan_pcpu_stats *vlan_stat;
+ vlan_stat = per_cpu_ptr(vlan->vlan_pcpu_stats, i);
+ seqcount_init(&vlan_stat->syncp);
+ }
+
+ return 0;
+}
+
+static void vlan_dev_uninit(struct rtnet_device *dev)
+{
+ struct vlan_priority_tci_mapping *pm;
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) {
+ while ((pm = vlan->egress_priority_map[i]) != NULL) {
+ vlan->egress_priority_map[i] = pm->next;
+ kfree(pm);
+ }
+ }
+}
+
+static void vlan_dev_free(struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+
+ vlan_dev_uninit(dev);
+ free_percpu(vlan->vlan_pcpu_stats);
+ vlan->vlan_pcpu_stats = NULL;
+ rt_unregister_rtnetdev(dev);
+ rt_rtdev_disconnect(dev);
+ rtdev_free(dev);
+}
+
+static bool vlan_hw_filter_capable(const struct rtnet_device *dev)
+{
+ return !!(dev->features & NETIF_F_HW_VLAN_CTAG_FILTER);
+}
+
+static struct rtnet_device *__rtvlan_find_dev(struct rtnet_device *dev, u16 vid)
+{
+ struct rtnet_device *vlan_dev;
+
+ if (vid == 0)
+ return dev;
+
+ list_for_each_entry(vlan_dev, &dev->vlan_link, vlan_link) {
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(vlan_dev);
+
+ if (vlan->vlan_id == vid)
+ return vlan_dev;
+ }
+
+ return NULL;
+}
+
+static struct rtnet_device *rtvlan_find_dev(struct rtnet_device *dev, u16 vid)
+{
+ struct rtnet_device *vlan_dev;
+ unsigned long flags;
+
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+ vlan_dev = __rtvlan_find_dev(dev, vid);
+ if (vlan_dev)
+ rtdev_reference(vlan_dev);
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+
+ return vlan_dev;
+}
+
+static int rtvlan_vid_add(struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct rtnet_device *real_dev = vlan->real_dev;
+ u16 vid = vlan->vlan_id;
+ unsigned long flags;
+ int err = 0;
+
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+ if (__rtvlan_find_dev(real_dev, vid)) {
+ err = -EEXIST;
+ goto out;
+ }
+
+ list_add(&dev->vlan_link, &real_dev->vlan_link);
+
+ if (vlan_hw_filter_capable(real_dev))
+ real_dev->vlan_rx_add_vid(real_dev, vid);
+ out:
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+
+ return err;
+}
+
+static void rtvlan_vid_del(struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct rtnet_device *real_dev = vlan->real_dev;
+ u16 vid = vlan->vlan_id;
+ unsigned long flags;
+
+ rtdm_lock_get_irqsave(&dev->rtdev_lock, flags);
+ if (__rtvlan_find_dev(real_dev, vid) != dev)
+ goto out;
+
+ list_del(&dev->vlan_link);
+
+ if (vlan_hw_filter_capable(real_dev))
+ real_dev->vlan_rx_kill_vid(real_dev, vid);
+ out:
+ rtdm_lock_put_irqrestore(&dev->rtdev_lock, flags);
+}
+
+void unregister_vlan_dev(struct rtnet_device *dev)
+{
+ struct rtvlan_dev_priv *vlan = rtvlan_dev_priv(dev);
+ struct rtnet_device *real_dev = vlan->real_dev;
+ u16 vlan_id = vlan->vlan_id;
+
+ if (vlan_id)
+ rtvlan_vid_del(dev);
+
+ /* Get rid of the vlan's reference to real_dev */
+ rtdev_dereference(real_dev);
+ vlan_dev_free(dev);
+}
+
+
+/* Attach a VLAN device to a mac address (ie Ethernet Card).
+ * Returns 0 if the device was created or a negative error code otherwise.
+ */
+static int register_vlan_device(struct rtnet_device *real_dev, u16 vlan_id)
+{
+ struct rtnet_device *new_dev;
+ struct rtvlan_dev_priv *vlan;
+ char name[IFNAMSIZ];
+ int err;
+
+ if (vlan_id >= VLAN_VID_MASK)
+ return -ERANGE;
+
+ /* Gotta set up the fields for the device.
+ Only one type of device name supported
+ */
+ switch (rtvlan_name_type) {
+ case VLAN_NAME_TYPE_RAW_PLUS_VID:
+ /* name will look like: eth1.0005 */
+ snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, vlan_id);
+ break;
+ case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
+ /* Put our vlan.VID in the name.
+ * Name will look like: vlan5
+ */
+ snprintf(name, IFNAMSIZ, "rtvlan%i", vlan_id);
+ break;
+ case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
+ /* Put our vlan.VID in the name.
+ * Name will look like: eth0.5
+ */
+ snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, vlan_id);
+ break;
+ case VLAN_NAME_TYPE_PLUS_VID:
+ /* Put our vlan.VID in the name.
+ * Name will look like: vlan0005
+ */
+ default:
+ snprintf(name, IFNAMSIZ, "rtvlan%.4i", vlan_id);
+ }
+
+ rtdev_reference(real_dev);
+
+ new_dev = rt_alloc_etherdev(sizeof(struct rtvlan_dev_priv), 0);
+ if (new_dev == NULL) {
+ err = -ENOBUFS;
+ goto err;
+ }
+ rtdev_alloc_name(new_dev, name);
+ rt_rtdev_connect(new_dev, &RTDEV_manager);
+ new_dev->vers = RTDEV_VERS_2_0;
+
+ new_dev->priv_flags |= IFF_802_1Q_VLAN;
+ new_dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
+
+ memset(new_dev->broadcast, 0, ETH_ALEN);
+
+ /* need 4 bytes for extra VLAN header info,
+ * hope the underlying device can handle it.
+ */
+ new_dev->mtu = real_dev->mtu;
+ new_dev->priv_flags |= (real_dev->priv_flags & IFF_UNICAST_FLT);
+
+ vlan = rtvlan_dev_priv(new_dev);
+ vlan->vlan_proto = htons(ETH_P_8021Q);
+ vlan->vlan_id = vlan_id;
+ vlan->real_dev = real_dev;
+ vlan->flags = VLAN_FLAG_REORDER_HDR;
+
+ err = vlan_dev_init(new_dev);
+ if (err < 0)
+ goto out_free_newdev;
+
+ err = rtvlan_vid_add(new_dev);
+ if (err < 0)
+ goto out_free_newdev;
+
+ err = rt_register_rtnetdev(new_dev);
+ if (err > 0) {
+ err = -err;
+ goto out_free_newdev;
+ }
+
+ return 0;
+
+out_free_newdev:
+ rt_rtdev_disconnect(new_dev);
+ rtdev_free(new_dev);
+ err:
+ rtdev_dereference(real_dev);
+ return err;
+}
+
+/*
+ * VLAN IOCTL handler.
+ * o execute requested action or pass command to the device driver
+ * arg is really a struct vlan_ioctl_args __user *.
+ */
+int rtvlan_ioctl_handler(void __user *arg)
+{
+ int err;
+ struct vlan_ioctl_args args;
+ struct rtnet_device *dev = NULL;
+
+ if (copy_from_user(&args, arg, sizeof(args)))
+ return -EFAULT;
+
+ /* Null terminate this sucker, just in case. */
+ args.device1[23] = 0;
+ args.u.device2[23] = 0;
+
+ switch (args.cmd) {
+ case SET_VLAN_INGRESS_PRIORITY_CMD:
+ case SET_VLAN_EGRESS_PRIORITY_CMD:
+ case SET_VLAN_FLAG_CMD:
+ case ADD_VLAN_CMD:
+ case DEL_VLAN_CMD:
+ case GET_VLAN_REALDEV_NAME_CMD:
+ case GET_VLAN_VID_CMD:
+ err = -ENODEV;
+ dev = rtdev_get_by_name(args.device1);
+ if (!dev)
+ goto out;
+
+ err = -EINVAL;
+ if (args.cmd != ADD_VLAN_CMD && !is_rtvlan_dev(dev))
+ goto out;
+ }
+
+ switch (args.cmd) {
+ case SET_VLAN_INGRESS_PRIORITY_CMD:
+ err = -EPERM;
+ vlan_dev_set_ingress_priority(dev,
+ args.u.skb_priority,
+ args.vlan_qos);
+ err = 0;
+ break;
+
+ case SET_VLAN_EGRESS_PRIORITY_CMD:
+ err = -EPERM;
+ err = vlan_dev_set_egress_priority(dev,
+ args.u.skb_priority,
+ args.vlan_qos);
+ break;
+
+ case SET_VLAN_FLAG_CMD:
+ err = -EPERM;
+ err = vlan_dev_change_flags(dev,
+ args.vlan_qos ? args.u.flag : 0,
+ args.u.flag);
+ break;
+
+ case SET_VLAN_NAME_TYPE_CMD:
+ err = -EPERM;
+ if ((args.u.name_type >= 0) &&
+ (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
+ rtvlan_name_type = args.u.name_type;
+ err = 0;
+ } else {
+ err = -EINVAL;
+ }
+ break;
+
+ case ADD_VLAN_CMD:
+ err = -EPERM;
+ err = register_vlan_device(dev, args.u.VID);
+ break;
+
+ case DEL_VLAN_CMD:
+ err = -EPERM;
+ rtdev_dereference(dev); /*
+ * Must dereference before unregistering
+ * in order to avoid infinite loop in
+ * rt_unregister_rtnetdev
+ */
+ unregister_vlan_dev(dev);
+ return 0;
+
+ case GET_VLAN_REALDEV_NAME_CMD:
+ err = 0;
+ vlan_dev_get_realdev_name(dev, args.u.device2);
+ if (copy_to_user(arg, &args,
+ sizeof(struct vlan_ioctl_args)))
+ err = -EFAULT;
+ break;
+
+ case GET_VLAN_VID_CMD:
+ err = 0;
+ args.u.VID = rtvlan_dev_vlan_id(dev);
+ if (copy_to_user(arg, &args,
+ sizeof(struct vlan_ioctl_args)))
+ err = -EFAULT;
+ break;
+
+ default:
+ err = -EOPNOTSUPP;
+ break;
+ }
+out:
+ if (dev)
+ rtdev_dereference(dev);
+
+ return err;
+}
+
+int rtvlan_proto_rx(struct rtskb *skb, struct rtpacket_type *pt)
+{
+ struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb->mac.raw;
+ struct rtvlan_pcpu_stats *rx_stats;
+ struct rtnet_device *vlan_dev;
+ struct rtvlan_dev_priv *vlan;
+ u16 vlan_tci;
+
+ vlan_tci = ntohs(veth->h_vlan_TCI);
+ vlan_dev = rtvlan_find_dev(skb->rtdev, vlan_tci & VLAN_VID_MASK);
+ if (!vlan_dev) {
+ kfree_rtskb(skb);
+ rtdev_dereference(skb->rtdev);
+ return 0;
+ }
+ vlan = rtvlan_dev_priv(vlan_dev);
+
+ skb->priority = vlan_get_ingress_priority(vlan_dev, vlan_tci);
+ skb->protocol = veth->h_vlan_encapsulated_proto;
+ skb->rtdev = vlan_dev;
+
+ if (skb->pkt_type == PACKET_OTHERHOST
+ && ether_addr_equal(veth->h_dest, vlan_dev->dev_addr))
+ skb->pkt_type = PACKET_HOST;
+
+ if (vlan->flags & VLAN_FLAG_REORDER_HDR) {
+ memmove(skb->mac.raw + VLAN_HLEN, skb->mac.raw, 2 * ETH_ALEN);
+#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_RTCAP
+ skb->cap_start += VLAN_HLEN;
+ skb->cap_len -= VLAN_HLEN;
+#endif
+ }
+ rtskb_pull(skb, VLAN_HLEN);
+
+ rx_stats = this_cpu_ptr(rtvlan_dev_priv(vlan_dev)->vlan_pcpu_stats);
+
+ raw_write_seqcount_begin(&rx_stats->syncp);
+ rx_stats->rx_packets++;
+ rx_stats->rx_bytes += skb->len;
+ if (skb->pkt_type == PACKET_MULTICAST)
+ rx_stats->rx_multicast++;
+ raw_write_seqcount_end(&rx_stats->syncp);
+
+ rt_stack_deliver(skb);
+ return 0;
+}
+
+struct rtpacket_type rtvlan_packet_type = {
+ .type = __constant_htons(ETH_P_8021Q),
+ .handler = rtvlan_proto_rx,
+};
+
+void rtvlan_proto_init(void)
+{
+ rtdev_add_pack(&rtvlan_packet_type);
+}
+
+void rtvlan_proto_release(void)
+{
+ rtdev_remove_pack(&rtvlan_packet_type);
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 06/31] utils/net: add VLAN filter configuration tool
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (4 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 05/31] net/stack: add support for VLAN filtering Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 07/31] net/udp: allow retrieving irq timestamp with SIOCGSTAMP ioctl Jean-Baptiste Trédez
` (26 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
utils/net/Makefile.am | 1 +
utils/net/rtvconfig.c | 257 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 258 insertions(+)
create mode 100644 utils/net/rtvconfig.c
diff --git a/utils/net/Makefile.am b/utils/net/Makefile.am
index 3b90f8adf..90e9002ea 100644
--- a/utils/net/Makefile.am
+++ b/utils/net/Makefile.am
@@ -11,6 +11,7 @@ sbin_PROGRAMS = \
rtcfg \
rtifconfig \
rtiwconfig \
+ rtvconfig \
rtping \
rtroute \
tdmacfg
diff --git a/utils/net/rtvconfig.c b/utils/net/rtvconfig.c
new file mode 100644
index 000000000..281e93422
--- /dev/null
+++ b/utils/net/rtvconfig.c
@@ -0,0 +1,257 @@
+//
+//Copyright (C) 2001 Ben Greear
+//
+//This program is free software; you can redistribute it and/or
+//modify it under the terms of the GNU Library General Public License
+//as published by the Free Software Foundation; either version 2
+//of the License, or (at your option) any later version.
+//
+//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.
+//
+//You should have received a copy of the GNU Library General Public License
+//along with this program; if not, write to the Free Software
+//Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// To contact the Author, Ben Greear: greearb@candelatech.com
+//
+
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <strings.h>
+#include <sys/ioctl.h>
+#include <linux/if_vlan.h>
+#include <linux/sockios.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+
+#define MAX_HOSTNAME 256
+
+
+static char* usage =
+ "\n"
+"Usage: add [interface-name] [vlan_id]\n"
+" rem [vlan-name]\n"
+" set_flag [interface-name] [flag-num] [0 | 1]\n"
+" set_egress_map [vlan-name] [skb_priority] [vlan_qos]\n"
+" set_ingress_map [vlan-name] [skb_priority] [vlan_qos]\n"
+" set_name_type [name-type]\n"
+"\n"
+"* The [interface-name] is the name of the ethernet card that hosts\n"
+" the VLAN you are talking about.\n"
+"* The vlan_id is the identifier (0-4095) of the VLAN you are operating on.\n"
+"* skb_priority is the priority in the socket buffer (sk_buff).\n"
+"* vlan_qos is the 3 bit priority in the VLAN header\n"
+"* name-type: VLAN_PLUS_VID (vlan0005), VLAN_PLUS_VID_NO_PAD (vlan5),\n"
+" DEV_PLUS_VID (eth0.0005), DEV_PLUS_VID_NO_PAD (eth0.5)\n"
+"* bind-type: PER_DEVICE # Allows vlan 5 on eth0 and eth1 to be unique.\n"
+" PER_KERNEL # Forces vlan 5 to be unique across all devices.\n"
+"* FLAGS: 1 REORDER_HDR When this is set, the VLAN device will move the\n"
+" ethernet header around to make it look exactly like a real\n"
+" ethernet device. This may help programs such as DHCPd which\n"
+" read the raw ethernet packet and make assumptions about the\n"
+" location of bytes. If you don't need it, don't turn it on, because\n"
+" there will be at least a small performance degradation. Default\n"
+" is OFF.\n";
+
+void show_usage() {
+ fprintf(stdout,usage);
+}
+
+int hex_to_bytes(char* bytes, int bytes_length, char* hex_str) {
+ int hlen;
+ int i;
+
+ int j = 0;
+ char hex[3];
+ char* stop; /* not used for any real purpose */
+
+ hlen = strlen(hex_str);
+
+ hex[2] = 0;
+
+ for (i = 0; i<hlen; i++) {
+
+ hex[0] = hex_str[i];
+ i++;
+ if (i >= hlen) {
+ return j; /* done */
+ }
+
+ hex[1] = hex_str[i];
+ bytes[j++] = (char)strtoul(hex, &stop, 16);
+ }
+ return j;
+}
+
+
+int main(int argc, char** argv) {
+ int fd;
+ struct vlan_ioctl_args if_request;
+
+ char* cmd = NULL;
+ char* if_name = NULL;
+ unsigned int vid = 0;
+ unsigned int skb_priority;
+ unsigned short vlan_qos;
+ unsigned int nm_type = VLAN_NAME_TYPE_PLUS_VID;
+
+ memset(&if_request, 0, sizeof(struct vlan_ioctl_args));
+
+ if ((argc < 3) || (argc > 5)) {
+ fprintf(stdout,"Expecting argc to be 3-5, inclusive. Was: %d\n",argc);
+
+ show_usage();
+ exit(1);
+ }
+ else {
+ cmd = argv[1];
+
+ if (strcasecmp(cmd, "set_name_type") == 0) {
+ if (strcasecmp(argv[2], "VLAN_PLUS_VID") == 0) {
+ nm_type = VLAN_NAME_TYPE_PLUS_VID;
+ }
+ else if (strcasecmp(argv[2], "VLAN_PLUS_VID_NO_PAD") == 0) {
+ nm_type = VLAN_NAME_TYPE_PLUS_VID_NO_PAD;
+ }
+ else if (strcasecmp(argv[2], "DEV_PLUS_VID") == 0) {
+ nm_type = VLAN_NAME_TYPE_RAW_PLUS_VID;
+ }
+ else if (strcasecmp(argv[2], "DEV_PLUS_VID_NO_PAD") == 0) {
+ nm_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
+ }
+ else {
+ // MATHIEU
+ //cerr << "Invalid name type.\n";
+ fprintf(stderr,"Invalid name type.\n");
+
+ show_usage();
+ exit(1);
+ }
+ if_request.u.name_type = nm_type;
+ }
+ else {
+ if_name = argv[2];
+ if (strlen(if_name) > 15) {
+ // MATHIEU
+ //cerr << "ERROR: if_name must be 15 characters or less." << endl;
+ fprintf(stderr,"ERROR: if_name must be 15 characters or less.\n");
+ exit(1);
+ }
+ strcpy(if_request.device1, if_name);
+ }
+
+ if (argc == 4) {
+ vid = atoi(argv[3]);
+ if_request.u.VID = vid;
+ }
+
+ if (argc == 5) {
+ skb_priority = atoi(argv[3]);
+ vlan_qos = atoi(argv[4]);
+ if_request.u.skb_priority = skb_priority;
+ if_request.vlan_qos = vlan_qos;
+ }
+ }
+
+ /* We use sockets now, instead of the file descriptor */
+ if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+ fprintf(stderr, "FATAL: Couldn't open a socket..go figure!\n");
+ exit(2);
+ }
+
+ /* add */
+ if (strcasecmp(cmd, "add") == 0) {
+ if_request.cmd = ADD_VLAN_CMD;
+ if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) {
+ fprintf(stderr,"ERROR: trying to add VLAN #%u to IF -:%s:- error: %s\n",
+ vid, if_name, strerror(errno));
+ exit(3);
+ }
+ else {
+ fprintf(stdout,"Added VLAN with VID == %u to IF -:%s:-\n",
+ vid, if_name);
+ if (vid == 1) {
+ fprintf(stdout, "WARNING: VLAN 1 does not work with many switches,\nconsider another number if you have problems.\n");
+ }
+ }
+ }//if
+ else if (strcasecmp(cmd, "rem") == 0) {
+ if_request.cmd = DEL_VLAN_CMD;
+ if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) {
+ fprintf(stderr,"ERROR: trying to remove VLAN -:%s:- error: %s\n",
+ if_name, strerror(errno));
+ exit(4);
+ }
+ else {
+ fprintf(stdout,"Removed VLAN -:%s:-\n", if_name);
+ }
+ }//if
+ else if (strcasecmp(cmd, "set_egress_map") == 0) {
+ if_request.cmd = SET_VLAN_EGRESS_PRIORITY_CMD;
+ if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) {
+ fprintf(stderr,"ERROR: trying to set egress map on device -:%s:- error: %s\n",
+ if_name, strerror(errno));
+ exit(5);
+ }
+ else {
+ fprintf(stdout,"Set egress mapping on device -:%s:- "
+ "Should be visible in /proc/net/vlan/%s\n",
+ if_name, if_name);
+ }
+ }
+ else if (strcasecmp(cmd, "set_ingress_map") == 0) {
+ if_request.cmd = SET_VLAN_INGRESS_PRIORITY_CMD;
+ if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) {
+ fprintf(stderr,"ERROR: trying to set ingress map on device -:%s:- error: %s\n",
+ if_name, strerror(errno));
+ exit(6);
+ }
+ else {
+ fprintf(stdout,"Set ingress mapping on device -:%s:- "
+ "Should be visible in /proc/net/vlan/%s\n",
+ if_name, if_name);
+ }
+ }
+ else if (strcasecmp(cmd, "set_flag") == 0) {
+ if_request.cmd = SET_VLAN_FLAG_CMD;
+ if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) {
+ fprintf(stderr,"ERROR: trying to set flag on device -:%s:- error: %s\n",
+ if_name, strerror(errno));
+ exit(7);
+ }
+ else {
+ fprintf(stdout,"Set flag on device -:%s:- "
+ "Should be visible in /proc/net/vlan/%s\n",
+ if_name, if_name);
+ }
+ }
+ else if (strcasecmp(cmd, "set_name_type") == 0) {
+ if_request.cmd = SET_VLAN_NAME_TYPE_CMD;
+ if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) {
+ fprintf(stderr,"ERROR: trying to set name type for VLAN subsystem, error: %s\n",
+ strerror(errno));
+ exit(8);
+ }
+ else {
+ fprintf(stdout,"Set name-type for VLAN subsystem."
+ " Should be visible in /proc/net/vlan/config\n");
+ }
+ }
+ else {
+ fprintf(stderr, "Unknown command -:%s:-\n", cmd);
+
+ show_usage();
+ exit(5);
+ }
+
+ return 0;
+}/* main */
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 07/31] net/udp: allow retrieving irq timestamp with SIOCGSTAMP ioctl
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (5 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 06/31] utils/net: add VLAN filter configuration tool Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 08/31] net/udp sendmsg: do not return an error if dest addr is null Jean-Baptiste Trédez
` (25 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/include/rtnet_socket.h | 2 ++
kernel/drivers/net/stack/ipv4/udp/udp.c | 9 +++++++++
2 files changed, 11 insertions(+)
diff --git a/kernel/drivers/net/stack/include/rtnet_socket.h b/kernel/drivers/net/stack/include/rtnet_socket.h
index af972c1a5..61bf8bea5 100644
--- a/kernel/drivers/net/stack/include/rtnet_socket.h
+++ b/kernel/drivers/net/stack/include/rtnet_socket.h
@@ -79,6 +79,8 @@ struct rtsocket {
int ifindex;
} packet;
} prot;
+
+ u64 timestamp;
};
static inline struct rtdm_fd *rt_socket_fd(struct rtsocket *sock)
diff --git a/kernel/drivers/net/stack/ipv4/udp/udp.c b/kernel/drivers/net/stack/ipv4/udp/udp.c
index dcaec5618..beceb28cf 100644
--- a/kernel/drivers/net/stack/ipv4/udp/udp.c
+++ b/kernel/drivers/net/stack/ipv4/udp/udp.c
@@ -359,6 +359,8 @@ int rt_udp_ioctl(struct rtdm_fd *fd, unsigned int request, void __user *arg)
struct rtsocket *sock = rtdm_fd_to_private(fd);
const struct _rtdm_setsockaddr_args *setaddr;
struct _rtdm_setsockaddr_args _setaddr;
+ unsigned long ns;
+ struct timeval tv;
/* fast path for common socket IOCTLs */
if (_IOC_TYPE(request) == RTIOC_TYPE_NETWORK)
@@ -377,6 +379,12 @@ int rt_udp_ioctl(struct rtdm_fd *fd, unsigned int request, void __user *arg)
return rt_udp_connect(fd, sock, setaddr->addr,
setaddr->addrlen);
+ case SIOCGSTAMP:
+ tv.tv_sec = xnclock_divrem_billion(sock->timestamp, &ns);
+ tv.tv_usec = ns / 1000;
+
+ return copy_to_user(arg, &tv, sizeof(tv));
+
default:
return rt_ip_ioctl(fd, request, arg);
}
@@ -464,6 +472,7 @@ ssize_t rt_udp_recvmsg(struct rtdm_fd *fd, struct user_msghdr *msg,
/* iterate over all IP fragments */
do {
+ sock->timestamp = skb->time_stamp;
rtskb_trim(skb, data_len);
block_size = skb->len;
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 08/31] net/udp sendmsg: do not return an error if dest addr is null
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (6 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 07/31] net/udp: allow retrieving irq timestamp with SIOCGSTAMP ioctl Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 09/31] net/stack: rtskb: increase buffer size Jean-Baptiste Trédez
` (24 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/ipv4/udp/udp.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/kernel/drivers/net/stack/ipv4/udp/udp.c b/kernel/drivers/net/stack/ipv4/udp/udp.c
index beceb28cf..2ff2febda 100644
--- a/kernel/drivers/net/stack/ipv4/udp/udp.c
+++ b/kernel/drivers/net/stack/ipv4/udp/udp.c
@@ -687,6 +687,9 @@ ssize_t rt_udp_sendmsg(struct rtdm_fd *fd, const struct user_msghdr *msg,
rtdm_lock_put_irqrestore(&udp_socket_base_lock, context);
+ if (daddr == 0)
+ return 0;
+
if ((daddr | dport) == 0) {
err = -EINVAL;
goto out;
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 09/31] net/stack: rtskb: increase buffer size
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (7 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 08/31] net/udp sendmsg: do not return an error if dest addr is null Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 10/31] net/stack: manager: ratelimit printk when dropping buffers Jean-Baptiste Trédez
` (23 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
The largest packet size an IGB device can handle is 2k. Since we have
a fixed buffer size, we need to accomodate for this.
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/include/rtskb.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/drivers/net/stack/include/rtskb.h b/kernel/drivers/net/stack/include/rtskb.h
index 4920b3916..8f0294fe3 100644
--- a/kernel/drivers/net/stack/include/rtskb.h
+++ b/kernel/drivers/net/stack/include/rtskb.h
@@ -269,7 +269,7 @@ struct rtskb_prio_queue {
#define DEFAULT_SOCKET_RTSKBS 16 /* default number of rtskb's in socket pools */
#define ALIGN_RTSKB_STRUCT_LEN SKB_DATA_ALIGN(sizeof(struct rtskb))
-#define RTSKB_SIZE 1544 /* maximum needed by pcnet32-rt */
+#define RTSKB_SIZE (2048 + NET_IP_ALIGN) /* maximum needed by igb */
extern unsigned int rtskb_pools; /* current number of rtskb pools */
extern unsigned int rtskb_pools_max; /* maximum number of rtskb pools */
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 10/31] net/stack: manager: ratelimit printk when dropping buffers
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (8 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 09/31] net/stack: rtskb: increase buffer size Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 11/31] net/ipv4: icmp: forward unused packets to proxy Jean-Baptiste Trédez
` (22 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/stack_mgr.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/drivers/net/stack/stack_mgr.c b/kernel/drivers/net/stack/stack_mgr.c
index a7e22458a..482f665f2 100644
--- a/kernel/drivers/net/stack/stack_mgr.c
+++ b/kernel/drivers/net/stack/stack_mgr.c
@@ -111,7 +111,7 @@ void rtnetif_rx(struct rtskb *skb)
RTNET_ASSERT(skb->rtdev != NULL, return;);
if (unlikely(rtskb_fifo_insert_inirq(&rx.fifo, skb) < 0)) {
- rtdm_printk("RTnet: dropping packet in %s()\n", __FUNCTION__);
+ rtdm_printk_ratelimited("RTnet: dropping packet in %s()\n", __FUNCTION__);
kfree_rtskb(skb);
}
}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 11/31] net/ipv4: icmp: forward unused packets to proxy
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (9 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 10/31] net/stack: manager: ratelimit printk when dropping buffers Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 12/31] net/drivers: e1000e: enable multicast Jean-Baptiste Trédez
` (21 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/ipv4/icmp.c | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/kernel/drivers/net/stack/ipv4/icmp.c b/kernel/drivers/net/stack/ipv4/icmp.c
index 8485614ec..61c7db58c 100644
--- a/kernel/drivers/net/stack/ipv4/icmp.c
+++ b/kernel/drivers/net/stack/ipv4/icmp.c
@@ -37,6 +37,7 @@
#include <ipv4_chrdev.h>
#include <ipv4/icmp.h>
#include <ipv4/ip_fragment.h>
+#include <ipv4/ip_input.h>
#include <ipv4/ip_output.h>
#include <ipv4/protocol.h>
#include <ipv4/route.h>
@@ -130,6 +131,14 @@ void rt_icmp_cleanup_echo_requests(void)
*/
static void rt_icmp_discard(struct rtskb *skb)
{
+#ifdef CONFIG_XENO_DRIVERS_NET_ADDON_PROXY
+ if (rt_ip_fallback_handler) {
+ /* If a fallback handler for IP protocol has been installed,
+ * call it. */
+ __rtskb_push(skb, skb->nh.iph->ihl*4 + sizeof(struct icmphdr));
+ rt_ip_fallback_handler(skb);
+ }
+#endif
}
static int rt_icmp_glue_reply_bits(const void *p, unsigned char *to,
@@ -207,6 +216,7 @@ static void rt_icmp_echo_reply(struct rtskb *skb)
rtdm_lock_put_irqrestore(&echo_calls_lock, context);
} else {
rtdm_lock_put_irqrestore(&echo_calls_lock, context);
+ rt_icmp_discard(skb);
return;
}
@@ -420,8 +430,12 @@ static struct rt_icmp_control rt_icmp_pointers[NR_ICMP_TYPES + 1] = {
*/
struct rtsocket *rt_icmp_dest_socket(struct rtskb *skb)
{
+ if (!list_empty(&echo_calls)) {
rt_socket_reference(icmp_socket);
return icmp_socket;
+ }
+
+ return NULL;
}
/***
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 12/31] net/drivers: e1000e: enable multicast
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (10 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 11/31] net/ipv4: icmp: forward unused packets to proxy Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 13/31] net/drivers: e1000e: enable VLAN filtering Jean-Baptiste Trédez
` (20 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/drivers/e1000e/e1000.h | 2 +-
kernel/drivers/net/drivers/e1000e/hw.h | 2 +-
kernel/drivers/net/drivers/e1000e/lib.c | 7 ++++---
kernel/drivers/net/drivers/e1000e/netdev.c | 6 ++++--
kernel/drivers/net/stack/include/ipv4/igmp.h | 4 ++--
kernel/drivers/net/stack/ipv4/igmp.c | 6 +++---
6 files changed, 15 insertions(+), 12 deletions(-)
diff --git a/kernel/drivers/net/drivers/e1000e/e1000.h b/kernel/drivers/net/drivers/e1000e/e1000.h
index 7454c6350..a682de8d2 100644
--- a/kernel/drivers/net/drivers/e1000e/e1000.h
+++ b/kernel/drivers/net/drivers/e1000e/e1000.h
@@ -574,7 +574,7 @@ extern s32 e1000e_setup_link(struct e1000_hw *hw);
extern void e1000_clear_vfta_generic(struct e1000_hw *hw);
extern void e1000e_init_rx_addrs(struct e1000_hw *hw, u16 rar_count);
extern void e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,
- u8 *mc_addr_list,
+ struct rtdev_mc_list *mc_addr_list,
u32 mc_addr_count);
extern void e1000e_rar_set(struct e1000_hw *hw, u8 *addr, u32 index);
extern s32 e1000e_set_fc_watermarks(struct e1000_hw *hw);
diff --git a/kernel/drivers/net/drivers/e1000e/hw.h b/kernel/drivers/net/drivers/e1000e/hw.h
index 247f79eea..94e91ed10 100644
--- a/kernel/drivers/net/drivers/e1000e/hw.h
+++ b/kernel/drivers/net/drivers/e1000e/hw.h
@@ -779,7 +779,7 @@ struct e1000_mac_operations {
s32 (*get_link_up_info)(struct e1000_hw *, u16 *, u16 *);
s32 (*led_on)(struct e1000_hw *);
s32 (*led_off)(struct e1000_hw *);
- void (*update_mc_addr_list)(struct e1000_hw *, u8 *, u32);
+ void (*update_mc_addr_list)(struct e1000_hw *, struct rtdev_mc_list *, u32);
s32 (*reset_hw)(struct e1000_hw *);
s32 (*init_hw)(struct e1000_hw *);
s32 (*setup_link)(struct e1000_hw *);
diff --git a/kernel/drivers/net/drivers/e1000e/lib.c b/kernel/drivers/net/drivers/e1000e/lib.c
index fbdccdc3b..e91037b33 100644
--- a/kernel/drivers/net/drivers/e1000e/lib.c
+++ b/kernel/drivers/net/drivers/e1000e/lib.c
@@ -356,7 +356,8 @@ static u32 e1000_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
* The caller must have a packed mc_addr_list of multicast addresses.
**/
void e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,
- u8 *mc_addr_list, u32 mc_addr_count)
+ struct rtdev_mc_list *mc_addr_list,
+ u32 mc_addr_count)
{
u32 hash_value, hash_bit, hash_reg;
int i;
@@ -366,13 +367,13 @@ void e1000e_update_mc_addr_list_generic(struct e1000_hw *hw,
/* update mta_shadow from mc_addr_list */
for (i = 0; (u32) i < mc_addr_count; i++) {
- hash_value = e1000_hash_mc_addr(hw, mc_addr_list);
+ hash_value = e1000_hash_mc_addr(hw, mc_addr_list->dmi_addr);
hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
hash_bit = hash_value & 0x1F;
hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit);
- mc_addr_list += (ETH_ALEN);
+ mc_addr_list = mc_addr_list->next;
}
/* replace the entire MTA table */
diff --git a/kernel/drivers/net/drivers/e1000e/netdev.c b/kernel/drivers/net/drivers/e1000e/netdev.c
index 5ce467911..a75afa808 100644
--- a/kernel/drivers/net/drivers/e1000e/netdev.c
+++ b/kernel/drivers/net/drivers/e1000e/netdev.c
@@ -2156,7 +2156,8 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
* Updates the Multicast Table Array.
* The caller must have a packed mc_addr_list of multicast addresses.
**/
-static void e1000_update_mc_addr_list(struct e1000_hw *hw, u8 *mc_addr_list,
+static void e1000_update_mc_addr_list(struct e1000_hw *hw,
+ struct rtdev_mc_list *mc_addr_list,
u32 mc_addr_count)
{
hw->mac.ops.update_mc_addr_list(hw, mc_addr_list, mc_addr_count);
@@ -2198,7 +2199,7 @@ static void e1000_set_multi(struct rtnet_device *netdev)
ew32(RCTL, rctl);
- e1000_update_mc_addr_list(hw, NULL, 0);
+ e1000_update_mc_addr_list(hw, netdev->mc_list, netdev->mc_count);
if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
e1000e_vlan_strip_enable(adapter);
@@ -4005,6 +4006,7 @@ static int e1000_probe(struct pci_dev *pdev,
netdev->open = e1000_open;
netdev->stop = e1000_close;
netdev->hard_start_xmit = e1000_xmit_frame;
+ netdev->set_multicast_list = e1000_set_multi;
//netdev->get_stats = e1000_get_stats;
netdev->map_rtskb = e1000_map_rtskb;
netdev->unmap_rtskb = e1000_unmap_rtskb;
diff --git a/kernel/drivers/net/stack/include/ipv4/igmp.h b/kernel/drivers/net/stack/include/ipv4/igmp.h
index a44e09041..3daa343e4 100644
--- a/kernel/drivers/net/stack/include/ipv4/igmp.h
+++ b/kernel/drivers/net/stack/include/ipv4/igmp.h
@@ -87,8 +87,8 @@ static inline bool rtnet_in_multicast(u32 addr)
}
#ifdef CONFIG_XENO_DRIVERS_NET_RTIPV4_IGMP
-int rt_ip_mc_join_group(struct rtsocket *sk, struct ip_mreq *imr);
-int rt_ip_mc_leave_group(struct rtsocket *sk, struct ip_mreq *imr);
+int rt_ip_mc_join_group(struct rtsocket *sk, const struct ip_mreq *imr);
+int rt_ip_mc_leave_group(struct rtsocket *sk, const struct ip_mreq *imr);
void rt_ip_mc_drop_socket(struct rtsocket *sk);
void rt_ip_mc_dec_group(struct rtnet_device *rtdev, u32 addr);
void rt_ip_mc_inc_group(struct rtnet_device *rtdev, u32 addr);
diff --git a/kernel/drivers/net/stack/ipv4/igmp.c b/kernel/drivers/net/stack/ipv4/igmp.c
index 3da21df5b..9568cedc7 100644
--- a/kernel/drivers/net/stack/ipv4/igmp.c
+++ b/kernel/drivers/net/stack/ipv4/igmp.c
@@ -339,7 +339,7 @@ void rt_ip_mc_dec_group(struct rtnet_device *rtdev, u32 addr)
rtdm_lock_put_irqrestore(&mc_list_lock, flags);
}
-static struct rtnet_device *rt_ip_mc_find_dev(struct ip_mreq *imr)
+static struct rtnet_device *rt_ip_mc_find_dev(const struct ip_mreq *imr)
{
struct rtnet_device *rtdev = NULL;
@@ -353,7 +353,7 @@ static struct rtnet_device *rt_ip_mc_find_dev(struct ip_mreq *imr)
* Join a socket to a group
*/
-int rt_ip_mc_join_group(struct rtsocket *sk, struct ip_mreq *imr)
+int rt_ip_mc_join_group(struct rtsocket *sk, const struct ip_mreq *imr)
{
int err = 0;
u32 addr = imr->imr_multiaddr.s_addr;
@@ -399,7 +399,7 @@ int rt_ip_mc_join_group(struct rtsocket *sk, struct ip_mreq *imr)
/*
* Ask a socket to leave a group.
*/
-int rt_ip_mc_leave_group(struct rtsocket *sk, struct ip_mreq *imr)
+int rt_ip_mc_leave_group(struct rtsocket *sk, const struct ip_mreq *imr)
{
u32 addr = imr->imr_multiaddr.s_addr;
struct rtnet_device *rtdev = rt_ip_mc_find_dev(imr);
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 13/31] net/drivers: e1000e: enable VLAN filtering
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (11 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 12/31] net/drivers: e1000e: enable multicast Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 14/31] net/drivers: e1000e: add netdevice stats Jean-Baptiste Trédez
` (19 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/drivers/e1000e/netdev.c | 28 ++++------------------
1 file changed, 5 insertions(+), 23 deletions(-)
diff --git a/kernel/drivers/net/drivers/e1000e/netdev.c b/kernel/drivers/net/drivers/e1000e/netdev.c
index a75afa808..4042cbd1a 100644
--- a/kernel/drivers/net/drivers/e1000e/netdev.c
+++ b/kernel/drivers/net/drivers/e1000e/netdev.c
@@ -1756,21 +1756,6 @@ static void e1000e_vlan_strip_disable(struct e1000_adapter *adapter)
ew32(CTRL, ctrl);
}
-/**
- * e1000e_vlan_strip_enable - helper to enable HW VLAN stripping
- * @adapter: board private structure to initialize
- **/
-static void e1000e_vlan_strip_enable(struct e1000_adapter *adapter)
-{
- struct e1000_hw *hw = &adapter->hw;
- u32 ctrl;
-
- /* enable VLAN tag insert/strip */
- ctrl = er32(CTRL);
- ctrl |= E1000_CTRL_VME;
- ew32(CTRL, ctrl);
-}
-
static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
{
struct rtnet_device *netdev = adapter->netdev;
@@ -2181,29 +2166,24 @@ static void e1000_set_multi(struct rtnet_device *netdev)
/* Check for Promiscuous and All Multicast modes */
rctl = er32(RCTL);
+ rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
if (netdev->flags & IFF_PROMISC) {
rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
- rctl &= ~E1000_RCTL_VFE;
/* Do not hardware filter VLANs in promisc mode */
e1000e_vlan_filter_disable(adapter);
} else {
if (netdev->flags & IFF_ALLMULTI) {
rctl |= E1000_RCTL_MPE;
- rctl &= ~E1000_RCTL_UPE;
} else {
- rctl &= ~(E1000_RCTL_UPE | E1000_RCTL_MPE);
+ e1000_update_mc_addr_list(hw, netdev->mc_list, netdev->mc_count);
}
e1000e_vlan_filter_enable(adapter);
+ rctl |= E1000_RCTL_UPE;
}
ew32(RCTL, rctl);
- e1000_update_mc_addr_list(hw, netdev->mc_list, netdev->mc_count);
-
- if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
- e1000e_vlan_strip_enable(adapter);
- else
e1000e_vlan_strip_disable(adapter);
}
@@ -4014,6 +3994,8 @@ static int e1000_probe(struct pci_dev *pdev,
netdev->mem_start = mmio_start;
netdev->mem_end = mmio_start + mmio_len;
+ netdev->vlan_rx_add_vid = e1000_vlan_rx_add_vid;
+ netdev->vlan_rx_kill_vid = e1000_vlan_rx_kill_vid;
adapter->bd_number = cards_found++;
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 14/31] net/drivers: e1000e: add netdevice stats
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (12 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 13/31] net/drivers: e1000e: enable VLAN filtering Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 15/31] net/drivers: igb: enable multicast Jean-Baptiste Trédez
` (18 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/drivers/e1000e/e1000.h | 5 +-
kernel/drivers/net/drivers/e1000e/netdev.c | 234 ++++++++++++++++++++-
2 files changed, 235 insertions(+), 4 deletions(-)
diff --git a/kernel/drivers/net/drivers/e1000e/e1000.h b/kernel/drivers/net/drivers/e1000e/e1000.h
index a682de8d2..fd28011db 100644
--- a/kernel/drivers/net/drivers/e1000e/e1000.h
+++ b/kernel/drivers/net/drivers/e1000e/e1000.h
@@ -378,6 +378,7 @@ struct e1000_adapter {
struct e1000_hw_stats stats;
struct e1000_phy_info phy_info;
struct e1000_phy_stats phy_stats;
+ struct net_device_stats netdev_stats;
/* Snapshot of PHY registers */
struct e1000_phy_regs phy_regs;
@@ -505,9 +506,7 @@ extern int e1000e_setup_rx_resources(struct e1000_adapter *adapter);
extern int e1000e_setup_tx_resources(struct e1000_adapter *adapter);
extern void e1000e_free_rx_resources(struct e1000_adapter *adapter);
extern void e1000e_free_tx_resources(struct e1000_adapter *adapter);
-extern struct rtnl_link_stats64 *e1000e_get_stats64(struct net_device *netdev,
- struct rtnl_link_stats64
- *stats);
+extern struct net_device_stats *e1000e_get_stats(struct rtnet_device *netdev);
extern void e1000e_set_interrupt_capability(struct e1000_adapter *adapter);
extern void e1000e_reset_interrupt_capability(struct e1000_adapter *adapter);
extern void e1000e_get_hw_control(struct e1000_adapter *adapter);
diff --git a/kernel/drivers/net/drivers/e1000e/netdev.c b/kernel/drivers/net/drivers/e1000e/netdev.c
index 4042cbd1a..46bbef371 100644
--- a/kernel/drivers/net/drivers/e1000e/netdev.c
+++ b/kernel/drivers/net/drivers/e1000e/netdev.c
@@ -2470,6 +2470,8 @@ static void e1000e_flush_descriptors(struct e1000_adapter *adapter)
e1e_flush();
}
+static void e1000e_update_stats(struct e1000_adapter *adapter);
+
void e1000e_down(struct e1000_adapter *adapter)
{
struct rtnet_device *netdev = adapter->netdev;
@@ -2506,6 +2508,10 @@ void e1000e_down(struct e1000_adapter *adapter)
rtnetif_carrier_off(netdev);
+ spin_lock(&adapter->stats64_lock);
+ e1000e_update_stats(adapter);
+ spin_unlock(&adapter->stats64_lock);
+
e1000e_flush_descriptors(adapter);
e1000_clean_tx_ring(adapter);
e1000_clean_rx_ring(adapter);
@@ -2880,6 +2886,186 @@ static void e1000_update_phy_info(unsigned long data)
rtdm_schedule_nrt_work(&adapter->update_phy_task);
}
+/**
+ * e1000e_update_phy_stats - Update the PHY statistics counters
+ * @adapter: board private structure
+ *
+ * Read/clear the upper 16-bit PHY registers and read/accumulate lower
+ **/
+static void e1000e_update_phy_stats(struct e1000_adapter *adapter)
+{
+ struct e1000_hw *hw = &adapter->hw;
+ s32 ret_val;
+ u16 phy_data;
+
+ ret_val = hw->phy.ops.acquire(hw);
+ if (ret_val)
+ return;
+
+ /* A page set is expensive so check if already on desired page.
+ * If not, set to the page with the PHY status registers.
+ */
+ hw->phy.addr = 1;
+ ret_val = e1000e_read_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
+ &phy_data);
+ if (ret_val)
+ goto release;
+ if (phy_data != (HV_STATS_PAGE << IGP_PAGE_SHIFT)) {
+ ret_val = hw->phy.ops.set_page(hw,
+ HV_STATS_PAGE << IGP_PAGE_SHIFT);
+ if (ret_val)
+ goto release;
+ }
+
+ /* Single Collision Count */
+ hw->phy.ops.read_reg_page(hw, HV_SCC_UPPER, &phy_data);
+ ret_val = hw->phy.ops.read_reg_page(hw, HV_SCC_LOWER, &phy_data);
+ if (!ret_val)
+ adapter->stats.scc += phy_data;
+
+ /* Excessive Collision Count */
+ hw->phy.ops.read_reg_page(hw, HV_ECOL_UPPER, &phy_data);
+ ret_val = hw->phy.ops.read_reg_page(hw, HV_ECOL_LOWER, &phy_data);
+ if (!ret_val)
+ adapter->stats.ecol += phy_data;
+
+ /* Multiple Collision Count */
+ hw->phy.ops.read_reg_page(hw, HV_MCC_UPPER, &phy_data);
+ ret_val = hw->phy.ops.read_reg_page(hw, HV_MCC_LOWER, &phy_data);
+ if (!ret_val)
+ adapter->stats.mcc += phy_data;
+
+ /* Late Collision Count */
+ hw->phy.ops.read_reg_page(hw, HV_LATECOL_UPPER, &phy_data);
+ ret_val = hw->phy.ops.read_reg_page(hw, HV_LATECOL_LOWER, &phy_data);
+ if (!ret_val)
+ adapter->stats.latecol += phy_data;
+
+ /* Collision Count - also used for adaptive IFS */
+ hw->phy.ops.read_reg_page(hw, HV_COLC_UPPER, &phy_data);
+ ret_val = hw->phy.ops.read_reg_page(hw, HV_COLC_LOWER, &phy_data);
+ if (!ret_val)
+ hw->mac.collision_delta = phy_data;
+
+ /* Defer Count */
+ hw->phy.ops.read_reg_page(hw, HV_DC_UPPER, &phy_data);
+ ret_val = hw->phy.ops.read_reg_page(hw, HV_DC_LOWER, &phy_data);
+ if (!ret_val)
+ adapter->stats.dc += phy_data;
+
+ /* Transmit with no CRS */
+ hw->phy.ops.read_reg_page(hw, HV_TNCRS_UPPER, &phy_data);
+ ret_val = hw->phy.ops.read_reg_page(hw, HV_TNCRS_LOWER, &phy_data);
+ if (!ret_val)
+ adapter->stats.tncrs += phy_data;
+
+release:
+ hw->phy.ops.release(hw);
+}
+
+/**
+ * e1000e_update_stats - Update the board statistics counters
+ * @adapter: board private structure
+ **/
+static void e1000e_update_stats(struct e1000_adapter *adapter)
+{
+ struct e1000_hw *hw = &adapter->hw;
+ struct pci_dev *pdev = adapter->pdev;
+
+ /* Prevent stats update while adapter is being reset, or if the pci
+ * connection is down.
+ */
+ if (adapter->link_speed == 0)
+ return;
+ if (pci_channel_offline(pdev))
+ return;
+
+ adapter->stats.crcerrs += er32(CRCERRS);
+ adapter->stats.gprc += er32(GPRC);
+ adapter->stats.gorc += er32(GORCL);
+ er32(GORCH); /* Clear gorc */
+ adapter->stats.bprc += er32(BPRC);
+ adapter->stats.mprc += er32(MPRC);
+ adapter->stats.roc += er32(ROC);
+
+ adapter->stats.mpc += er32(MPC);
+
+ /* Half-duplex statistics */
+ if (adapter->link_duplex == HALF_DUPLEX) {
+ if (adapter->flags2 & FLAG2_HAS_PHY_STATS) {
+ e1000e_update_phy_stats(adapter);
+ } else {
+ adapter->stats.scc += er32(SCC);
+ adapter->stats.ecol += er32(ECOL);
+ adapter->stats.mcc += er32(MCC);
+ adapter->stats.latecol += er32(LATECOL);
+ adapter->stats.dc += er32(DC);
+
+ hw->mac.collision_delta = er32(COLC);
+
+ if ((hw->mac.type != e1000_82574) &&
+ (hw->mac.type != e1000_82583))
+ adapter->stats.tncrs += er32(TNCRS);
+ }
+ adapter->stats.colc += hw->mac.collision_delta;
+ }
+
+ adapter->stats.xonrxc += er32(XONRXC);
+ adapter->stats.xontxc += er32(XONTXC);
+ adapter->stats.xoffrxc += er32(XOFFRXC);
+ adapter->stats.xofftxc += er32(XOFFTXC);
+ adapter->stats.gptc += er32(GPTC);
+ adapter->stats.gotc += er32(GOTCL);
+ er32(GOTCH); /* Clear gotc */
+ adapter->stats.rnbc += er32(RNBC);
+ adapter->stats.ruc += er32(RUC);
+
+ adapter->stats.mptc += er32(MPTC);
+ adapter->stats.bptc += er32(BPTC);
+
+ /* used for adaptive IFS */
+
+ hw->mac.tx_packet_delta = er32(TPT);
+ adapter->stats.tpt += hw->mac.tx_packet_delta;
+
+ adapter->stats.algnerrc += er32(ALGNERRC);
+ adapter->stats.rxerrc += er32(RXERRC);
+ adapter->stats.cexterr += er32(CEXTERR);
+ adapter->stats.tsctc += er32(TSCTC);
+ adapter->stats.tsctfc += er32(TSCTFC);
+
+ /* Fill out the OS statistics structure */
+ adapter->netdev_stats.multicast = adapter->stats.mprc;
+ adapter->netdev_stats.collisions = adapter->stats.colc;
+
+ /* Rx Errors */
+
+ /* RLEC on some newer hardware can be incorrect so build
+ * our own version based on RUC and ROC
+ */
+ adapter->netdev_stats.rx_errors = adapter->stats.rxerrc +
+ adapter->stats.crcerrs + adapter->stats.algnerrc +
+ adapter->stats.ruc + adapter->stats.roc + adapter->stats.cexterr;
+ adapter->netdev_stats.rx_length_errors = adapter->stats.ruc +
+ adapter->stats.roc;
+ adapter->netdev_stats.rx_crc_errors = adapter->stats.crcerrs;
+ adapter->netdev_stats.rx_frame_errors = adapter->stats.algnerrc;
+ adapter->netdev_stats.rx_missed_errors = adapter->stats.mpc;
+
+ /* Tx Errors */
+ adapter->netdev_stats.tx_errors = adapter->stats.ecol + adapter->stats.latecol;
+ adapter->netdev_stats.tx_aborted_errors = adapter->stats.ecol;
+ adapter->netdev_stats.tx_window_errors = adapter->stats.latecol;
+ adapter->netdev_stats.tx_carrier_errors = adapter->stats.tncrs;
+
+ /* Tx Dropped needs to be maintained elsewhere */
+
+ /* Management Stats */
+ adapter->stats.mgptc += er32(MGTPTC);
+ adapter->stats.mgprc += er32(MGTPRC);
+ adapter->stats.mgpdc += er32(MGTPDC);
+}
+
/**
* e1000_phy_read_status - Update the PHY register status snapshot
* @adapter: board private structure
@@ -3176,6 +3362,7 @@ static void e1000_watchdog_task(struct work_struct *work)
link_up:
spin_lock(&adapter->stats64_lock);
+ e1000e_update_stats(adapter);
mac->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
adapter->tpt_old = adapter->stats.tpt;
@@ -3440,6 +3627,51 @@ static void e1000_reset_task(struct work_struct *work)
e1000e_reinit_locked(adapter);
}
+struct net_device_stats *e1000_get_stats(struct rtnet_device *netdev)
+{
+ struct e1000_adapter *adapter = rtnetdev_priv(netdev);
+ struct net_device_stats *stats = &adapter->netdev_stats;
+
+ memset(stats, 0, sizeof(*stats));
+ spin_lock(&adapter->stats64_lock);
+ e1000e_update_stats(adapter);
+ /* Fill out the OS statistics structure */
+ stats->rx_bytes = adapter->stats.gorc;
+ stats->rx_packets = adapter->stats.gprc;
+ stats->tx_bytes = adapter->stats.gotc;
+ stats->tx_packets = adapter->stats.gptc;
+ stats->multicast = adapter->stats.mprc;
+ stats->collisions = adapter->stats.colc;
+
+ /* Rx Errors */
+
+ /*
+ * RLEC on some newer hardware can be incorrect so build
+ * our own version based on RUC and ROC
+ */
+ stats->rx_errors = adapter->stats.rxerrc +
+ adapter->stats.crcerrs + adapter->stats.algnerrc +
+ adapter->stats.ruc + adapter->stats.roc +
+ adapter->stats.cexterr;
+ stats->rx_length_errors = adapter->stats.ruc +
+ adapter->stats.roc;
+ stats->rx_crc_errors = adapter->stats.crcerrs;
+ stats->rx_frame_errors = adapter->stats.algnerrc;
+ stats->rx_missed_errors = adapter->stats.mpc;
+
+ /* Tx Errors */
+ stats->tx_errors = adapter->stats.ecol +
+ adapter->stats.latecol;
+ stats->tx_aborted_errors = adapter->stats.ecol;
+ stats->tx_window_errors = adapter->stats.latecol;
+ stats->tx_carrier_errors = adapter->stats.tncrs;
+
+ /* Tx Dropped needs to be maintained elsewhere */
+
+ spin_unlock(&adapter->stats64_lock);
+ return stats;
+}
+
static int e1000_init_phy_wakeup(struct e1000_adapter *adapter, u32 wufc)
{
struct e1000_hw *hw = &adapter->hw;
@@ -3987,7 +4219,7 @@ static int e1000_probe(struct pci_dev *pdev,
netdev->stop = e1000_close;
netdev->hard_start_xmit = e1000_xmit_frame;
netdev->set_multicast_list = e1000_set_multi;
- //netdev->get_stats = e1000_get_stats;
+ netdev->get_stats = e1000_get_stats;
netdev->map_rtskb = e1000_map_rtskb;
netdev->unmap_rtskb = e1000_unmap_rtskb;
strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 15/31] net/drivers: igb: enable multicast
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (13 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 14/31] net/drivers: e1000e: add netdevice stats Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 16/31] net/drivers: igb: enable VLAN filtering Jean-Baptiste Trédez
` (17 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/drivers/igb/e1000_mac.c | 6 ++---
kernel/drivers/net/drivers/igb/e1000_mac.h | 2 +-
kernel/drivers/net/drivers/igb/igb_main.c | 30 +++++-----------------
3 files changed, 11 insertions(+), 27 deletions(-)
diff --git a/kernel/drivers/net/drivers/igb/e1000_mac.c b/kernel/drivers/net/drivers/igb/e1000_mac.c
index 500c92877..765604d5f 100644
--- a/kernel/drivers/net/drivers/igb/e1000_mac.c
+++ b/kernel/drivers/net/drivers/igb/e1000_mac.c
@@ -440,7 +440,7 @@ static u32 igb_hash_mc_addr(struct e1000_hw *hw, u8 *mc_addr)
* The caller must have a packed mc_addr_list of multicast addresses.
**/
void igb_update_mc_addr_list(struct e1000_hw *hw,
- u8 *mc_addr_list, u32 mc_addr_count)
+ struct rtdev_mc_list *mc_addr, u32 mc_addr_count)
{
u32 hash_value, hash_bit, hash_reg;
int i;
@@ -450,13 +450,13 @@ void igb_update_mc_addr_list(struct e1000_hw *hw,
/* update mta_shadow from mc_addr_list */
for (i = 0; (u32) i < mc_addr_count; i++) {
- hash_value = igb_hash_mc_addr(hw, mc_addr_list);
+ hash_value = igb_hash_mc_addr(hw, mc_addr->dmi_addr);
hash_reg = (hash_value >> 5) & (hw->mac.mta_reg_count - 1);
hash_bit = hash_value & 0x1F;
hw->mac.mta_shadow[hash_reg] |= (1 << hash_bit);
- mc_addr_list += (ETH_ALEN);
+ mc_addr = mc_addr->next;
}
/* replace the entire MTA table */
diff --git a/kernel/drivers/net/drivers/igb/e1000_mac.h b/kernel/drivers/net/drivers/igb/e1000_mac.h
index b50d57c5d..a3ad413a0 100644
--- a/kernel/drivers/net/drivers/igb/e1000_mac.h
+++ b/kernel/drivers/net/drivers/igb/e1000_mac.h
@@ -49,7 +49,7 @@ s32 igb_get_speed_and_duplex_copper(struct e1000_hw *hw, u16 *speed,
s32 igb_id_led_init(struct e1000_hw *hw);
s32 igb_led_off(struct e1000_hw *hw);
void igb_update_mc_addr_list(struct e1000_hw *hw,
- u8 *mc_addr_list, u32 mc_addr_count);
+ struct rtdev_mc_list *mc_addr, u32 mc_addr_count);
s32 igb_setup_link(struct e1000_hw *hw);
s32 igb_validate_mdi_setting(struct e1000_hw *hw);
s32 igb_write_8bit_ctrl_reg(struct e1000_hw *hw, u32 reg,
diff --git a/kernel/drivers/net/drivers/igb/igb_main.c b/kernel/drivers/net/drivers/igb/igb_main.c
index 1dc4732ee..9a3998719 100644
--- a/kernel/drivers/net/drivers/igb/igb_main.c
+++ b/kernel/drivers/net/drivers/igb/igb_main.c
@@ -2070,8 +2070,8 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
netdev->map_rtskb = igb_map_rtskb;
netdev->unmap_rtskb = igb_unmap_rtskb;
netdev->do_ioctl = igb_ioctl;
+ netdev->set_multicast_list = igb_set_rx_mode;
#if 0
- netdev->set_multicast_list = igb_set_multi;
netdev->set_mac_address = igb_set_mac;
netdev->change_mtu = igb_change_mtu;
@@ -3370,34 +3370,18 @@ static int igb_write_mc_addr_list(struct rtnet_device *netdev)
{
struct igb_adapter *adapter = rtnetdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
-#if 0
- struct netdev_hw_addr *ha;
- u8 *mta_list;
- int i;
- if (netdev_mc_empty(netdev)) {
+ struct rtdev_mc_list *mc_addr = netdev->mc_list;
+ unsigned mc_addr_count = netdev->mc_count;
+
+ if (!mc_addr_count) {
/* nothing to program, so clear mc list */
igb_update_mc_addr_list(hw, NULL, 0);
- igb_restore_vf_multicasts(adapter);
return 0;
}
- mta_list = kzalloc(netdev_mc_count(netdev) * 6, GFP_ATOMIC);
- if (!mta_list)
- return -ENOMEM;
-
- /* The shared function expects a packed array of only addresses. */
- i = 0;
- netdev_for_each_mc_addr(ha, netdev)
- memcpy(mta_list + (i++ * ETH_ALEN), ha->addr, ETH_ALEN);
+ igb_update_mc_addr_list(hw, mc_addr, mc_addr_count);
- igb_update_mc_addr_list(hw, mta_list, i);
- kfree(mta_list);
-
- return netdev_mc_count(netdev);
-#else
- igb_update_mc_addr_list(hw, NULL, 0);
- return 0;
-#endif
+ return mc_addr_count;
}
/**
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 16/31] net/drivers: igb: enable VLAN filtering
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (14 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 15/31] net/drivers: igb: enable multicast Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 17/31] demo/net: add rtnet tests Jean-Baptiste Trédez
` (16 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/drivers/igb/igb_main.c | 23 ++++++++++++++++-------
1 file changed, 16 insertions(+), 7 deletions(-)
diff --git a/kernel/drivers/net/drivers/igb/igb_main.c b/kernel/drivers/net/drivers/igb/igb_main.c
index 9a3998719..2bdcdc5ac 100644
--- a/kernel/drivers/net/drivers/igb/igb_main.c
+++ b/kernel/drivers/net/drivers/igb/igb_main.c
@@ -224,7 +224,8 @@ static int igb_ioctl(struct rtnet_device *, struct ifreq *ifr, int cmd);
static void igb_reset_task(struct work_struct *);
static void igb_vlan_mode(struct rtnet_device *netdev,
netdev_features_t features);
-static int igb_vlan_rx_add_vid(struct rtnet_device *, __be16, u16);
+static void igb_vlan_rx_add_vid(struct rtnet_device *, u16);
+static void igb_vlan_rx_kill_vid(struct rtnet_device *, u16);
static void igb_restore_vlan(struct igb_adapter *);
static void igb_rar_set_qsel(struct igb_adapter *, u8 *, u32 , u8);
@@ -2071,6 +2072,8 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
netdev->unmap_rtskb = igb_unmap_rtskb;
netdev->do_ioctl = igb_ioctl;
netdev->set_multicast_list = igb_set_rx_mode;
+ netdev->vlan_rx_add_vid = igb_vlan_rx_add_vid;
+ netdev->vlan_rx_kill_vid = igb_vlan_rx_kill_vid;
#if 0
netdev->set_mac_address = igb_set_mac;
netdev->change_mtu = igb_change_mtu;
@@ -2135,10 +2138,8 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
NETIF_F_HW_VLAN_CTAG_RX |
NETIF_F_HW_VLAN_CTAG_TX;
-#if 0
/* set this bit last since it cannot be part of hw_features */
netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
-#endif
netdev->priv_flags |= IFF_SUPP_NOFCS;
@@ -5135,8 +5136,7 @@ static void igb_vlan_mode(struct rtnet_device *netdev, netdev_features_t feature
igb_rlpml_set(adapter);
}
-static int igb_vlan_rx_add_vid(struct rtnet_device *netdev,
- __be16 proto, u16 vid)
+static void igb_vlan_rx_add_vid(struct rtnet_device *netdev, u16 vid)
{
struct igb_adapter *adapter = rtnetdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
@@ -5145,8 +5145,17 @@ static int igb_vlan_rx_add_vid(struct rtnet_device *netdev,
igb_vfta_set(hw, vid, true);
set_bit(vid, adapter->active_vlans);
+}
- return 0;
+static void igb_vlan_rx_kill_vid(struct rtnet_device *netdev, u16 vid)
+{
+ struct igb_adapter *adapter = rtnetdev_priv(netdev);
+ struct e1000_hw *hw = &adapter->hw;
+
+ /* if vid was not present in VLVF just remove it from table */
+ igb_vfta_set(hw, vid, false);
+
+ clear_bit(vid, adapter->active_vlans);
}
static void igb_restore_vlan(struct igb_adapter *adapter)
@@ -5156,7 +5165,7 @@ static void igb_restore_vlan(struct igb_adapter *adapter)
igb_vlan_mode(adapter->netdev, adapter->netdev->features);
for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
- igb_vlan_rx_add_vid(adapter->netdev, htons(ETH_P_8021Q), vid);
+ igb_vlan_rx_add_vid(adapter->netdev, vid);
}
static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake,
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 17/31] demo/net: add rtnet tests
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (15 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 16/31] net/drivers: igb: enable VLAN filtering Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 18/31] net/stack: increase maximum number of ethernet devices Jean-Baptiste Trédez
` (15 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
configure.ac | 1 +
demo/Makefile.am | 2 +-
demo/net/Makefile.am | 78 ++++++++
demo/net/mcast-receiver.c | 205 ++++++++++++++++++++
demo/net/mcast-sender.c | 151 +++++++++++++++
demo/net/raw-ethernet.c | 100 ++++++++++
demo/net/rtt-mcast-measure.c | 210 ++++++++++++++++++++
demo/net/rtt-mcast-responder.c | 109 +++++++++++
demo/net/rtt-responder.c | 193 +++++++++++++++++++
demo/net/rtt-sender.c | 341 +++++++++++++++++++++++++++++++++
demo/net/rttcp-client.c | 212 ++++++++++++++++++++
demo/net/rttcp-server.c | 181 +++++++++++++++++
demo/net/udp-send.c | 136 +++++++++++++
13 files changed, 1918 insertions(+), 1 deletion(-)
create mode 100644 demo/net/Makefile.am
create mode 100644 demo/net/mcast-receiver.c
create mode 100644 demo/net/mcast-sender.c
create mode 100644 demo/net/raw-ethernet.c
create mode 100644 demo/net/rtt-mcast-measure.c
create mode 100644 demo/net/rtt-mcast-responder.c
create mode 100644 demo/net/rtt-responder.c
create mode 100644 demo/net/rtt-sender.c
create mode 100644 demo/net/rttcp-client.c
create mode 100644 demo/net/rttcp-server.c
create mode 100644 demo/net/udp-send.c
diff --git a/configure.ac b/configure.ac
index bd5fd5ba9..8fd322d54 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1010,6 +1010,7 @@ AC_CONFIG_FILES([ \
demo/posix/cobalt/Makefile \
demo/alchemy/Makefile \
demo/alchemy/cobalt/Makefile \
+ demo/net/Makefile \
include/Makefile \
include/cobalt/uapi/Makefile \
include/cobalt/uapi/asm-generic/Makefile \
diff --git a/demo/Makefile.am b/demo/Makefile.am
index fe5107c25..2839d074b 100644
--- a/demo/Makefile.am
+++ b/demo/Makefile.am
@@ -1,2 +1,2 @@
-SUBDIRS = posix alchemy
+SUBDIRS = posix alchemy net
diff --git a/demo/net/Makefile.am b/demo/net/Makefile.am
new file mode 100644
index 000000000..f9755bace
--- /dev/null
+++ b/demo/net/Makefile.am
@@ -0,0 +1,78 @@
+demodir = @XENO_DEMO_DIR@
+
+CCLD = $(top_srcdir)/scripts/wrap-link.sh $(CC)
+
+demo_PROGRAMS = \
+ mcast-receiver \
+ mcast-sender \
+ raw-ethernet \
+ rttcp-client \
+ rttcp-server \
+ rtt-mcast-measure \
+ rtt-mcast-responder \
+ rtt-responder \
+ rtt-sender \
+ udp-send
+
+cppflags = \
+ $(XENO_USER_CFLAGS) \
+ -I$(top_srcdir)/include
+
+ldflags = @XENO_AUTOINIT_LDFLAGS@ $(XENO_POSIX_WRAPPERS)
+
+ldadd = \
+ @XENO_CORE_LDADD@ \
+ @XENO_USER_LDADD@ \
+ -lpthread -lrt
+
+mcast_receiver_SOURCES = mcast-receiver.c
+mcast_receiver_CPPFLAGS = $(cppflags)
+mcast_receiver_LDFLAGS = $(ldflags)
+mcast_receiver_LDADD = $(ldadd)
+
+mcast_sender_SOURCES = mcast-sender.c
+mcast_sender_CPPFLAGS = $(cppflags)
+mcast_sender_LDFLAGS = $(ldflags)
+mcast_sender_LDADD = $(ldadd)
+
+raw_ethernet_SOURCES = raw-ethernet.c
+raw_ethernet_CPPFLAGS = $(cppflags)
+raw_ethernet_LDFLAGS = $(ldflags)
+raw_ethernet_LDADD = $(ldadd)
+
+rttcp_client_SOURCES = rttcp-client.c
+rttcp_client_CPPFLAGS = $(cppflags)
+rttcp_client_LDFLAGS = $(ldflags)
+rttcp_client_LDADD = $(ldadd)
+
+rttcp_server_SOURCES = rttcp-server.c
+rttcp_server_CPPFLAGS = $(cppflags)
+rttcp_server_LDFLAGS = $(ldflags)
+rttcp_server_LDADD = $(ldadd)
+
+rtt_mcast_measure_SOURCES = rtt-mcast-measure.c
+rtt_mcast_measure_CPPFLAGS = $(cppflags)
+rtt_mcast_measure_LDFLAGS = $(ldflags)
+rtt_mcast_measure_LDADD = ../../lib/alchemy/libalchemy.la \
+ ../../lib/copperplate/libcopperplate.la \
+ $(ldadd)
+
+rtt_mcast_responder_SOURCES = rtt-mcast-responder.c
+rtt_mcast_responder_CPPFLAGS = $(cppflags)
+rtt_mcast_responder_LDFLAGS = $(ldflags)
+rtt_mcast_responder_LDADD = $(ldadd)
+
+rtt_responder_SOURCES = rtt-responder.c
+rtt_responder_CPPFLAGS = $(cppflags)
+rtt_responder_LDFLAGS = $(ldflags)
+rtt_responder_LDADD = $(ldadd)
+
+rtt_sender_SOURCES = rtt-sender.c
+rtt_sender_CPPFLAGS = $(cppflags)
+rtt_sender_LDFLAGS = $(ldflags)
+rtt_sender_LDADD = $(ldadd)
+
+udp_send_SOURCES = udp-send.c
+udp_send_CPPFLAGS = $(cppflags)
+udp_send_LDFLAGS = $(ldflags)
+udp_send_LDADD = $(ldadd)
diff --git a/demo/net/mcast-receiver.c b/demo/net/mcast-receiver.c
new file mode 100644
index 000000000..a121d0d32
--- /dev/null
+++ b/demo/net/mcast-receiver.c
@@ -0,0 +1,205 @@
+/*
+ * listener.c -- joins a multicast group and echoes all data it receives from
+ * the group to its stdout...
+ *
+ * Antony Courtney, 25/11/94
+ * Modified by: Frédéric Bastien (25/03/04)
+ * to compile without warning and work correctly
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <time.h>
+#include <string.h>
+#include <sched.h>
+#include <pthread.h>
+#include <errno.h>
+
+#include <sys/ioctl.h>
+#include <linux/sockios.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <signal.h>
+
+#include <execinfo.h>
+
+#define HELLO_PORT 12345
+#define HELLO_GROUP "225.0.0.37"
+#define MSGBUFSIZE 256
+
+#define TO_US(ns) \
+ (ns) / 1000, (ns) % 1000
+
+static void check(const char *file, int line, const char *service, int status, int err)
+{
+ if (status >= 0)
+ return;
+
+ pthread_setmode_np(PTHREAD_WARNSW, 0, NULL);
+ __real_fprintf(stderr, "%s:%d: %s: %s\n", file, line, service, strerror(err));
+
+ exit(EXIT_FAILURE);
+}
+
+#define check_pthread(expr) \
+ ({ \
+ int _status = (expr); \
+ check(__FILE__, __LINE__, #expr, -_status, _status); \
+ })
+
+#define check_unix(expr) \
+ ({ \
+ int _status = (expr); \
+ check(__FILE__, __LINE__, #expr, _status, errno); \
+ })
+
+static const char *reason_str[] = {
+ [SIGDEBUG_UNDEFINED] = "received SIGDEBUG for unknown reason",
+ [SIGDEBUG_MIGRATE_SIGNAL] = "received signal",
+ [SIGDEBUG_MIGRATE_SYSCALL] = "invoked syscall",
+ [SIGDEBUG_MIGRATE_FAULT] = "triggered fault",
+ [SIGDEBUG_MIGRATE_PRIOINV] = "owner is not in real-time mode",
+ [SIGDEBUG_NOMLOCK] = "process memory not locked",
+ [SIGDEBUG_WATCHDOG] = "watchdog triggered (period too short?)",
+ [SIGDEBUG_LOCK_BREAK] = "scheduler lock break",
+ [SIGDEBUG_MUTEX_SLEEP] = "caller sleeps with mutex",
+};
+
+static void sigdebug(int sig, siginfo_t *si, void *context)
+{
+ const char fmt[] = "%s, aborting.\n";
+ unsigned int reason = sigdebug_reason(si);
+ int n __attribute__ ((unused));
+ static char buffer[256];
+ void *bt[32];
+ int nentries;
+
+ if (reason >= sizeof(reason_str) / sizeof(reason_str[0]))
+ reason = SIGDEBUG_UNDEFINED;
+
+ n = snprintf(buffer, sizeof(buffer), fmt, reason_str[reason]);
+ n = write(STDERR_FILENO, buffer, n);
+ nentries = backtrace(bt, sizeof(bt) / sizeof(bt[0]));
+ backtrace_symbols_fd(bt, nentries, STDERR_FILENO);
+
+ signal(sig, SIG_DFL);
+ kill(getpid(), sig);
+}
+
+int main(int argc, char *argv[])
+{
+ unsigned long long min, max, sum, count, gmin, gmax, gsum, gcount;
+ struct sigaction sa __attribute__((unused));
+ struct sockaddr_in addr;
+ int fd, err;
+ struct ip_mreq mreq;
+ socklen_t addrlen;
+ struct timespec last_print;
+ struct sched_param sparm;
+ char msgbuf[MSGBUFSIZE];
+ bool first = true;
+
+ if (argc != 2) {
+ fprintf(stderr, "Local ip address expected as first and "
+ "only argument\n");
+ exit(EXIT_FAILURE);
+ }
+
+ sparm.sched_priority = 97;
+ check_pthread(pthread_setschedparam(pthread_self(),
+ SCHED_FIFO, &sparm));
+
+ check_unix(fd = socket(AF_INET,SOCK_DGRAM,0));
+
+ sigemptyset(&sa.sa_mask);
+ sa.sa_sigaction = sigdebug;
+ sa.sa_flags = SA_SIGINFO;
+ check_unix(sigaction(SIGDEBUG, &sa, NULL));
+
+ memset(&addr,0,sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = inet_addr(argv[1]);
+ addr.sin_port = htons(HELLO_PORT);
+
+ check_unix(bind(fd, (struct sockaddr *)&addr,sizeof(addr)));
+
+ mreq.imr_multiaddr.s_addr = inet_addr(HELLO_GROUP);
+ mreq.imr_interface.s_addr = addr.sin_addr.s_addr;
+ check_unix(setsockopt(fd,IPPROTO_IP,
+ IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)));
+
+ gmin = min = ~0ULL;
+ gmax = max = 0;
+ gsum = sum = 0;
+ gcount = count = 0;
+
+ check_pthread(pthread_setmode_np(0, PTHREAD_WARNSW, NULL));
+
+ check_unix(clock_gettime(CLOCK_REALTIME, &last_print));
+
+ while (1) {
+ struct timespec now;
+ struct timeval packet;
+ unsigned long long diff;
+
+ addrlen = sizeof(addr);
+ check_unix(recvfrom(fd, msgbuf, sizeof(msgbuf), 0,
+ (struct sockaddr *)&addr, &addrlen));
+ check_unix(clock_gettime(CLOCK_REALTIME, &now));
+
+ err = ioctl(fd, SIOCGSTAMP, &packet);
+ if (err < 0) {
+ perror("ioctl");
+ exit(1);
+ }
+
+ if (first) {
+ first = false;
+ continue;
+ }
+
+ diff = now.tv_sec * 1000000000ULL + now.tv_nsec -
+ (packet.tv_sec * 1000000000ULL
+ + packet.tv_usec * 1000ULL);
+ if ((long long)diff < 0)
+ printf("%lu.%09lu - %lu.%06lu\n",
+ now.tv_sec, now.tv_nsec,
+ packet.tv_sec, packet.tv_usec);
+
+ if (diff < min)
+ min = diff;
+ if (diff > max)
+ max = diff;
+ sum += diff;
+ ++count;
+
+ diff = now.tv_sec * 1000000000ULL + now.tv_nsec -
+ (last_print.tv_sec * 1000000000ULL
+ + last_print.tv_nsec);
+ if (diff < 1000000000)
+ continue;
+
+ if (min < gmin)
+ gmin = min;
+ if (max > gmax)
+ gmax = max;
+ gsum += sum;
+ gcount += count;
+
+ printf("%g pps, %Lu.%03Lu %Lu.%03Lu %Lu.%03Lu "
+ "| %Lu.%03Lu %Lu.%03Lu %Lu.%03Lu\n",
+ count / (diff / 1000000000.0),
+ TO_US(min), TO_US(sum / count), TO_US(max),
+ TO_US(gmin), TO_US(gsum / gcount), TO_US(gmax));
+
+ min = ~0ULL;
+ max = 0;
+ sum = 0;
+ count = 0;
+ last_print = now;
+ }
+}
diff --git a/demo/net/mcast-sender.c b/demo/net/mcast-sender.c
new file mode 100644
index 000000000..3e4a083f9
--- /dev/null
+++ b/demo/net/mcast-sender.c
@@ -0,0 +1,151 @@
+/*
+ * sender.c -- multicasts "hello, world!" to a multicast group once a second
+ *
+ * Antony Courtney, 25/11/94
+ */
+
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sched.h>
+#include <pthread.h>
+#include <errno.h>
+#include <signal.h>
+#include <execinfo.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+
+#define HELLO_PORT 12345
+#define HELLO_GROUP "225.0.0.37"
+
+static void check(const char *file, int line, const char *service, int status, int err)
+{
+ if (status >= 0)
+ return;
+
+ pthread_setmode_np(PTHREAD_WARNSW, 0, NULL);
+ __real_fprintf(stderr, "%s:%d: %s: %s\n", file, line, service, strerror(err));
+
+ exit(EXIT_FAILURE);
+}
+
+#define check_pthread(expr) \
+ ({ \
+ int _status = (expr); \
+ check(__FILE__, __LINE__, #expr, -_status, _status); \
+ })
+
+#define check_unix(expr) \
+ ({ \
+ int _status = (expr); \
+ check(__FILE__, __LINE__, #expr, _status, errno); \
+ })
+
+static const char *reason_str[] = {
+ [SIGDEBUG_UNDEFINED] = "received SIGDEBUG for unknown reason",
+ [SIGDEBUG_MIGRATE_SIGNAL] = "received signal",
+ [SIGDEBUG_MIGRATE_SYSCALL] = "invoked syscall",
+ [SIGDEBUG_MIGRATE_FAULT] = "triggered fault",
+ [SIGDEBUG_MIGRATE_PRIOINV] = "owner is not in real-time mode",
+ [SIGDEBUG_NOMLOCK] = "process memory not locked",
+ [SIGDEBUG_WATCHDOG] = "watchdog triggered (period too short?)",
+ [SIGDEBUG_LOCK_BREAK] = "scheduler lock break",
+ [SIGDEBUG_MUTEX_SLEEP] = "caller sleeps with mutex",
+};
+
+static void sigdebug(int sig, siginfo_t *si, void *context)
+{
+ const char fmt[] = "%s, aborting.\n";
+ unsigned int reason = sigdebug_reason(si);
+ int n __attribute__ ((unused));
+ static char buffer[256];
+ void *bt[32];
+ int nentries;
+
+ if (reason >= sizeof(reason_str) / sizeof(reason_str[0]))
+ reason = SIGDEBUG_UNDEFINED;
+
+ n = snprintf(buffer, sizeof(buffer), fmt, reason_str[reason]);
+ n = write(STDERR_FILENO, buffer, n);
+ nentries = backtrace(bt, sizeof(bt) / sizeof(bt[0]));
+ backtrace_symbols_fd(bt, nentries, STDERR_FILENO);
+
+ signal(sig, SIG_DFL);
+ kill(getpid(), sig);
+}
+
+static void usage(const char *progname)
+{
+ fprintf(stderr, "%s address frequency\n"
+ "Starts sending 'frequency' multicast UDP packets per second on"
+ " the interface\nwith IP address 'address'.\n",
+ progname);
+}
+
+int main(int argc, char *argv[])
+{
+ struct sigaction sa __attribute__((unused));
+ struct sockaddr_in addr;
+ int fd;
+ char message[] = "Hello, World!\n";
+ struct sched_param sparm;
+ struct timespec next;
+ double freq;
+ unsigned period_ns;
+
+ if (argc != 3) {
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+
+ freq = atof(argv[2]);
+ period_ns = freq ? 1000000000 / freq : 0;
+
+ check_unix(fd = socket(AF_INET,SOCK_DGRAM, 0));
+
+ addr.sin_addr.s_addr = inet_addr(argv[1]);
+
+ check_unix(setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF,
+ &addr.sin_addr, sizeof(addr.sin_addr)));
+
+ sigemptyset(&sa.sa_mask);
+ sa.sa_sigaction = sigdebug;
+ sa.sa_flags = SA_SIGINFO;
+ check_unix(sigaction(SIGDEBUG, &sa, NULL));
+
+ memset(&addr,0,sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = inet_addr(HELLO_GROUP);
+ addr.sin_port = htons(HELLO_PORT);
+
+ sparm.sched_priority = 99;
+ check_pthread(pthread_setschedparam(pthread_self(),
+ SCHED_FIFO, &sparm));
+
+ check_unix(clock_gettime(CLOCK_MONOTONIC, &next));
+
+ check_pthread(pthread_setmode_np(0, PTHREAD_WARNSW, NULL));
+
+ while (1) {
+ check_unix(sendto(fd,message,sizeof(message), 0,
+ (struct sockaddr *)&addr,
+ sizeof(addr)));
+
+ if (!period_ns)
+ continue;
+
+ next.tv_nsec += period_ns;
+ if (next.tv_nsec >= 1000000000) {
+ next.tv_nsec -= 1000000000;
+ next.tv_sec++;
+ }
+ check_unix(clock_nanosleep(CLOCK_MONOTONIC,
+ TIMER_ABSTIME, &next, NULL));
+ }
+}
diff --git a/demo/net/raw-ethernet.c b/demo/net/raw-ethernet.c
new file mode 100644
index 000000000..f0448d8f6
--- /dev/null
+++ b/demo/net/raw-ethernet.c
@@ -0,0 +1,100 @@
+/***
+ *
+ * examples/xenomai/posix/raw-ethernet.c
+ *
+ * SOCK_RAW sender - sends out Ethernet frames via a SOCK_RAW packet socket
+ *
+ * Copyright (C) 2006 Jan Kiszka <jan.kiszka@web.de>
+ *
+ * RTnet - real-time networking example
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+
+char buffer[1514];
+int sock;
+
+
+int main(int argc, char *argv[])
+{
+ struct sched_param param = { .sched_priority = 1 };
+ ssize_t len;
+ struct sockaddr_ll addr;
+ struct ifreq ifr;
+ struct timespec delay = { 1, 0 };
+ struct ether_header *eth = (struct ether_header *)buffer;
+
+
+ if (argc < 2) {
+ printf("usage: %s <interface>\n", argv[0]);
+ return 0;
+ }
+
+ if ((sock = socket(PF_PACKET, SOCK_RAW, htons(0x1234))) < 0) {
+ perror("socket cannot be created");
+ return 1;
+ }
+
+ strncpy(ifr.ifr_name, argv[1], IFNAMSIZ-1)[IFNAMSIZ-1] = 0;
+ if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0) {
+ perror("cannot get interface index");
+ close(sock);
+ return 1;
+ }
+
+ addr.sll_family = AF_PACKET;
+ addr.sll_protocol = htons(0x1234);
+ addr.sll_ifindex = ifr.ifr_ifindex;
+
+ if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ perror("cannot bind to local ip/port");
+ close(sock);
+ return 1;
+ }
+
+ memset(eth->ether_dhost, 0xFF, ETH_HLEN);
+ eth->ether_type = htons(0x1234);
+
+ pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
+
+ while (1) {
+ len = send(sock, buffer, sizeof(buffer), 0);
+ if (len < 0)
+ break;
+
+ printf("Sent frame of %zd bytes\n", len);
+
+ nanosleep(&delay, NULL);
+ }
+
+ /* This call also leaves primary mode, required for socket cleanup. */
+ printf("shutting down\n");
+
+ return 0;
+}
diff --git a/demo/net/rtt-mcast-measure.c b/demo/net/rtt-mcast-measure.c
new file mode 100644
index 000000000..dc6650645
--- /dev/null
+++ b/demo/net/rtt-mcast-measure.c
@@ -0,0 +1,210 @@
+/*
+ * Multicast RTT sender. Derived from.
+ *
+ * listener.c -- joins a multicast group and echoes all data it receives from
+ * the group to its stdout...
+ *
+ * Antony Courtney, 25/11/94
+ * Modified by: Frédéric Bastien (25/03/04)
+ * to compile without warning and work correctly
+ */
+
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <alchemy/task.h>
+#include <alchemy/timer.h>
+#include <rtdm/net.h>
+
+#define RTT_PORT 12345
+#define RTT_RECEIVER_GROUP "225.0.0.37"
+#define RTT_SENDER_GROUP "224.0.0.37"
+
+#define rt_inet_aton inet_addr
+#define do_div(ull, u) ({ unsigned long _r = ull % u; ull /= u; _r; })
+
+static int fd;
+
+static void thread(void *arg)
+{
+ unsigned long long gmin, gmax, gsum, gcount;
+ struct sockaddr_in addr, to_addr;
+ RTIME period, start;
+ int i, nbytes, err;
+ socklen_t addrlen;
+ char msgbuf[1500];
+
+ (void)arg;
+
+ memset(&to_addr, 0, sizeof(to_addr));
+ to_addr.sin_family = AF_INET;
+ to_addr.sin_addr.s_addr = rt_inet_aton(RTT_RECEIVER_GROUP);
+ to_addr.sin_port = htons(RTT_PORT);
+
+ start = 0;
+ period = 1000000;
+ err = rt_task_set_periodic(NULL, start, period);
+ if (err < 0) {
+ printf("make_periodic: %d\n", err);
+ rt_task_delete(NULL);
+ }
+
+ gmin = ~0ULL;
+ gmax = 0;
+ gsum = 0;
+ gcount = 0;
+
+ /* now just enter a receive/send loop */
+ for(;;) {
+ unsigned long long smin, smax, ssum, savg, gavg,
+ smin_us, smin_ns, savg_us, savg_ns, smax_us, smax_ns,
+ gmin_us, gmin_ns, gavg_us, gavg_ns, gmax_us, gmax_ns;
+
+ smin = ~0ULL;
+ smax = 0;
+ ssum = 0;
+
+ for (i = 0; i < 1000; i++) {
+ unsigned long overruns;
+ long long rtt;
+
+ err = rt_task_wait_period(&overruns);
+ if (err == -ETIMEDOUT)
+ printf("%ld overruns\n", overruns);
+ else if (err < 0) {
+ printf("wait_period: %d\n", err);
+ rt_task_delete(NULL);
+ }
+
+ rtt = rt_timer_read();
+ err = sendto(fd, msgbuf, 4, 0,
+ (struct sockaddr *)&to_addr, sizeof(to_addr));
+ if (err < 0) {
+ perror("sendto");
+ rt_task_delete(NULL);
+ }
+
+ addrlen = sizeof(addr);
+ nbytes = recvfrom(fd, msgbuf, sizeof(msgbuf), 0,
+ (struct sockaddr *)&addr, &addrlen);
+ rtt = rt_timer_read() - rtt;
+ if (nbytes <= 0) {
+ perror("recvfrom");
+ rt_task_delete(NULL);
+ }
+
+ if (rtt < smin)
+ smin = rtt;
+ if (rtt > smax)
+ smax = rtt;
+ ssum += rtt;
+ }
+
+ if (smin < gmin)
+ gmin = smin;
+ if (smax > gmax)
+ gmax = smax;
+ gsum += ssum;
+ gcount += 1000;
+
+ savg = ssum + 500;
+ do_div(savg, 1000);
+
+ gavg = gsum + gcount / 2;
+ do_div(gavg, gcount);
+
+ smin_us = smin;
+ smin_ns = do_div(smin_us, 1000);
+
+ savg_us = savg;
+ savg_ns = do_div(savg_us, 1000);
+
+ smax_us = smax;
+ smax_ns = do_div(smax_us, 1000);
+
+ gmin_us = gmin;
+ gmin_ns = do_div(gmin_us, 1000);
+
+ gavg_us = gavg;
+ gavg_ns = do_div(gavg_us, 1000);
+
+ gmax_us = gmax;
+ gmax_ns = do_div(gmax_us, 1000);
+
+ printf("%Lu.%03Lu %Lu.%03Lu %Lu.%03Lu | %Lu.%03Lu %Lu.%03Lu %Lu.%03Lu\n",
+ smin_us, smin_ns, savg_us, savg_ns, smax_us, smax_ns,
+ gmin_us, gmin_ns, gavg_us, gavg_ns, gmax_us, gmax_ns);
+ }
+}
+
+static int create_thread(RT_TASK *tid, int mode, void *arg)
+{
+ struct sockaddr_in addr;
+ struct ip_mreq mreq;
+ int err;
+
+ /* create what looks like an ordinary UDP socket */
+ fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (fd < 0) {
+ perror("socket");
+ return fd;
+ }
+
+ /* set up destination address */
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ if (!arg) {
+ printf("Local ip address expected as first and only argument\n");
+ return -EINVAL;
+ }
+
+ addr.sin_addr.s_addr = rt_inet_aton(arg);
+ addr.sin_port = htons(RTT_PORT);
+
+ /* bind to receive address */
+ err = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
+ if (err < 0) {
+ perror("bind");
+ return err;
+ }
+
+ /* use setsockopt() to request that the kernel join a multicast group */
+ mreq.imr_multiaddr.s_addr = rt_inet_aton(RTT_SENDER_GROUP);
+ mreq.imr_interface.s_addr = addr.sin_addr.s_addr;
+ err = setsockopt(fd, IPPROTO_IP,
+ IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
+ if (err < 0) {
+ perror("setsockopt");
+ rt_task_delete(NULL);
+ }
+
+ err = rt_task_spawn(tid, "rtt-mcast-measure", 8192, 99, mode,
+ thread, NULL);
+ if (err < 0)
+ printf("rt_task_spawn: %d\n", err);
+
+ return err;
+}
+
+int main(int argc, char *argv[])
+{
+ RT_TASK tid;
+ int err;
+
+ err = create_thread(&tid, T_JOINABLE, argc >= 2 ? argv[1] : NULL);
+ if (err)
+ exit(EXIT_FAILURE);
+
+ err = rt_task_join(&tid);
+ if (err < 0)
+ printf("rt_task_join: %d\n", err);
+
+ exit(EXIT_FAILURE);
+}
diff --git a/demo/net/rtt-mcast-responder.c b/demo/net/rtt-mcast-responder.c
new file mode 100644
index 000000000..b8f7dee02
--- /dev/null
+++ b/demo/net/rtt-mcast-responder.c
@@ -0,0 +1,109 @@
+/*
+ * Multicast RTT responder. Derived from.
+ *
+ * listener.c -- joins a multicast group and echoes all data it receives from
+ * the group to its stdout...
+ *
+ * Antony Courtney, 25/11/94
+ * Modified by: Frédéric Bastien (25/03/04)
+ * to compile without warning and work correctly
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <pthread.h>
+#include <rtdm/net.h>
+
+
+#define RTT_PORT 12345
+#define RTT_RECEIVER_GROUP "225.0.0.37"
+#define RTT_SENDER_GROUP "224.0.0.37"
+
+int main(int argc, char *argv[])
+{
+ struct sockaddr_in addr, to_addr;
+ struct sched_param sparm;
+ int add_rtskbs = 128;
+ struct ip_mreq mreq;
+ int fd, err, nbytes;
+ socklen_t addrlen;
+ char msgbuf[1500];
+
+ sparm.sched_priority = 99;
+ err = pthread_setschedparam(pthread_self(), SCHED_FIFO, &sparm);
+ if (err) {
+ fprintf(stderr, "pthread_setschedparam: %d\n", err);
+ exit(EXIT_FAILURE);
+ }
+
+ /* create what looks like an ordinary UDP socket */
+ fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (fd < 0) {
+ perror("socket");
+ exit(EXIT_FAILURE);
+ }
+
+ /* set up destination address */
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ if (argc != 2) {
+ fprintf(stderr, "Local ip address expected as first and only argument\n");
+ exit(EXIT_FAILURE);
+ }
+
+ addr.sin_addr.s_addr = inet_addr(argv[1]);
+ addr.sin_port = htons(RTT_PORT);
+
+ /* bind to receive address */
+ err = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
+ if (err < 0) {
+ perror("bind");
+ exit(EXIT_FAILURE);
+ }
+
+ memset(&to_addr, 0, sizeof(to_addr));
+ to_addr.sin_family = AF_INET;
+ to_addr.sin_addr.s_addr = inet_addr(RTT_SENDER_GROUP);
+ to_addr.sin_port = htons(RTT_PORT);
+
+ /* use setsockopt() to request that the kernel join a multicast group */
+ mreq.imr_multiaddr.s_addr = inet_addr(RTT_RECEIVER_GROUP);
+ mreq.imr_interface.s_addr = addr.sin_addr.s_addr;
+ err = setsockopt(fd, IPPROTO_IP,
+ IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
+ if (err < 0) {
+ perror("setsockopt");
+ exit(EXIT_FAILURE);
+ }
+
+ err = ioctl(fd, RTNET_RTIOC_EXTPOOL, &add_rtskbs);
+ if (err < 0)
+ perror("ioctl(RTNET_RTIOC_EXTPOOL)\n");
+
+ /* now just enter a receive/send loop */
+ while (1) {
+ addrlen = sizeof(addr);
+ nbytes = recvfrom(fd, msgbuf, sizeof(msgbuf), 0,
+ (struct sockaddr *)&addr, &addrlen);
+ if (nbytes <= 0) {
+ perror("recvfrom");
+ exit(EXIT_FAILURE);
+ }
+
+ err = sendto(fd, msgbuf, nbytes, 0,
+ (struct sockaddr *)&to_addr, sizeof(addr));
+ if (err < 0) {
+ perror("sendto");
+ exit(EXIT_FAILURE);
+ }
+ }
+}
diff --git a/demo/net/rtt-responder.c b/demo/net/rtt-responder.c
new file mode 100644
index 000000000..6e31a1ff2
--- /dev/null
+++ b/demo/net/rtt-responder.c
@@ -0,0 +1,193 @@
+/***
+ *
+ * examples/xenomai/posix/rtt-responder.c
+ *
+ * Round-Trip Time Responder - listens and sends back a packet
+ *
+ * Based on Ulrich Marx's module, later ported over user space POSIX.
+ *
+ * Copyright (C) 2002 Ulrich Marx <marx@kammer.uni-hannover.de>
+ * 2002 Marc Kleine-Budde <kleine-budde@gmx.de>
+ * 2004, 2006 Jan Kiszka <jan.kiszka@web.de>
+ *
+ * RTnet - real-time networking example
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/mman.h>
+#include <arpa/inet.h>
+#include <limits.h>
+
+#include <rtdm/net.h>
+
+char *dest_ip_s = "";
+char *local_ip_s = "";
+unsigned int reply_size = 0;
+
+pthread_t rt_thread;
+
+#define RCV_PORT 36000
+#define XMT_PORT 35999
+
+struct sockaddr_in dest_addr;
+
+int sock;
+
+char buffer[65536];
+
+
+static void *responder(void* arg)
+{
+ struct sched_param param = { .sched_priority = 81 };
+ struct msghdr rx_msg;
+ struct iovec iov;
+ ssize_t ret;
+
+
+ if (dest_addr.sin_addr.s_addr == INADDR_ANY) {
+ rx_msg.msg_name = &dest_addr;
+ rx_msg.msg_namelen = sizeof(dest_addr);
+ } else {
+ rx_msg.msg_name = NULL;
+ rx_msg.msg_namelen = 0;
+ }
+ rx_msg.msg_namelen = sizeof(struct sockaddr_in);
+ rx_msg.msg_iov = &iov;
+ rx_msg.msg_iovlen = 1;
+ rx_msg.msg_control = NULL;
+ rx_msg.msg_controllen = 0;
+
+ pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
+
+ while(1) {
+ iov.iov_base = &buffer;
+ iov.iov_len = sizeof(buffer);
+
+ ret = recvmsg(sock, &rx_msg, 0);
+ if (ret <= 0) {
+ printf("terminating responder thread\n");
+ return NULL;
+ }
+
+ sendto(sock, &buffer, reply_size ? : ret, 0,
+ (struct sockaddr *)&dest_addr,
+ sizeof(struct sockaddr_in));
+ }
+}
+
+
+int main(int argc, char *argv[])
+{
+ struct sockaddr_in local_addr;
+ int add_rtskbs = 30;
+ pthread_attr_t thattr;
+ int ret;
+
+
+ while (1) {
+ switch (getopt(argc, argv, "d:l:s:")) {
+ case 'd':
+ dest_ip_s = optarg;
+ break;
+
+ case 'l':
+ local_ip_s = optarg;
+ break;
+
+ case 's':
+ reply_size = atoi(optarg);
+ break;
+
+ case -1:
+ goto end_of_opt;
+
+ default:
+ printf("usage: %s [-d <dest_ip>] [-l <local_ip>] "
+ "[-s <reply_size>]\n", argv[0]);
+ return 0;
+ }
+ }
+ end_of_opt:
+
+ if (dest_ip_s[0]) {
+ inet_aton(dest_ip_s, &dest_addr.sin_addr);
+ dest_addr.sin_port = htons(XMT_PORT);
+ } else
+ dest_addr.sin_addr.s_addr = INADDR_ANY;
+
+ if (local_ip_s[0])
+ inet_aton(local_ip_s, &local_addr.sin_addr);
+ else
+ local_addr.sin_addr.s_addr = INADDR_ANY;
+
+ if (reply_size > 65505)
+ reply_size = 65505;
+ else if (reply_size < sizeof(struct timespec))
+ reply_size = sizeof(struct timespec);
+
+ printf("destination ip address: %s = %08x\n",
+ dest_ip_s[0] ? dest_ip_s : "SENDER", dest_addr.sin_addr.s_addr);
+ printf("local ip address: %s = %08x\n",
+ local_ip_s[0] ? local_ip_s : "INADDR_ANY", local_addr.sin_addr.s_addr);
+ printf("reply size: %d\n", reply_size);
+
+ /* create rt-socket */
+ if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+ perror("socket cannot be created");
+ return 1;
+ }
+
+ /* bind the rt-socket to local_addr */
+ local_addr.sin_family = AF_INET;
+ local_addr.sin_port = htons(RCV_PORT);
+ if (bind(sock, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
+ perror("cannot bind to local ip/port");
+ close(sock);
+ return 1;
+ }
+
+ /* extend the socket pool */
+ ret = ioctl(sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs);
+ if (ret < 0)
+ perror("ioctl(RTNET_RTIOC_EXTPOOL)\n");
+
+ /* create reply rt-thread */
+ pthread_attr_init(&thattr);
+ pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
+ pthread_attr_setstacksize(&thattr, PTHREAD_STACK_MIN);
+ ret = pthread_create(&rt_thread, &thattr, &responder, NULL);
+ if (ret) {
+ close(sock);
+ errno = ret; perror("pthread_create failed");
+ return 1;
+ }
+
+ pause();
+
+ pthread_kill(rt_thread, SIGHUP);
+ pthread_join(rt_thread, NULL);
+
+ return 0;
+}
diff --git a/demo/net/rtt-sender.c b/demo/net/rtt-sender.c
new file mode 100644
index 000000000..ae75a6f19
--- /dev/null
+++ b/demo/net/rtt-sender.c
@@ -0,0 +1,341 @@
+/***
+ *
+ * examples/xenomai/posix/rtt-requester.c
+ *
+ * Round-Trip Time Requester - sends packet, receives echo, evaluates
+ * and displays per-station round-trip times
+ *
+ * Based on Ulrich Marx's module, adopted to RTmac and later ported over
+ * user space POSIX.
+ *
+ * Copyright (C) 2002 Ulrich Marx <marx@kammer.uni-hannover.de>
+ * 2002 Marc Kleine-Budde <kleine-budde@gmx.de>
+ * 2006 Jan Kiszka <jan.kiszka@web.de>
+ *
+ * RTnet - real-time networking example
+ * RTmac - real-time media access control example
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <errno.h>
+#include <mqueue.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/mman.h>
+#include <arpa/inet.h>
+#include <limits.h>
+
+#include <rtdm/net.h>
+
+char *dest_ip_s = "127.0.0.1";
+char *local_ip_s = "";
+unsigned int cycle = 50000; /* 50 ms */
+
+pthread_t xmit_thread;
+pthread_t recv_thread;
+
+#define RCV_PORT 35999
+#define XMT_PORT 36000
+
+#define DEFAULT_ADD_BUFFERS 30
+
+struct sockaddr_in dest_addr;
+
+int sock;
+mqd_t mq;
+
+#define BUFSIZE 1500
+union {
+ char data[BUFSIZE];
+ struct timespec tx_date;
+} packet;
+
+struct station_stats {
+ struct in_addr addr;
+ long long last, min, max;
+ unsigned long count;
+};
+
+struct packet_stats {
+ struct in_addr addr;
+ long long rtt;
+};
+
+#define MAX_STATIONS 100
+static struct station_stats station[MAX_STATIONS];
+
+
+static struct station_stats *lookup_stats(struct in_addr addr)
+{
+ int i;
+
+ for (i = 0; i < MAX_STATIONS; i++) {
+ if (station[i].addr.s_addr == addr.s_addr)
+ break;
+ if (station[i].addr.s_addr == 0) {
+ station[i].addr = addr;
+ station[i].min = LONG_MAX;
+ station[i].max = LONG_MIN;
+ break;
+ }
+ }
+ if (i == MAX_STATIONS)
+ return NULL;
+ return &station[i];
+}
+
+
+static void *transmitter(void *arg)
+{
+ struct sched_param param = { .sched_priority = 80 };
+ struct timespec next_period;
+ struct timespec tx_date;
+
+
+ pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
+
+ clock_gettime(CLOCK_MONOTONIC, &next_period);
+
+ while(1) {
+ next_period.tv_nsec += cycle * 1000;
+ if (next_period.tv_nsec >= 1000000000) {
+ next_period.tv_nsec = 0;
+ next_period.tv_sec++;
+ }
+
+ clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next_period, NULL);
+
+ clock_gettime(CLOCK_MONOTONIC, &tx_date);
+
+ /* transmit the request packet containing the local time */
+ if (sendto(sock, &tx_date, sizeof(tx_date), 0,
+ (struct sockaddr *)&dest_addr,
+ sizeof(struct sockaddr_in)) < 0) {
+ if (errno == EBADF)
+ printf("terminating transmitter thread\n");
+ else
+ perror("sendto failed");
+ return NULL;
+ }
+ }
+}
+
+
+static void *receiver(void *arg)
+{
+ struct sched_param param = { .sched_priority = 82 };
+ struct msghdr msg;
+ struct iovec iov;
+ struct sockaddr_in addr;
+ struct timespec rx_date;
+ struct packet_stats stats;
+ int ret;
+
+
+ msg.msg_name = &addr;
+ msg.msg_namelen = sizeof(addr);
+ msg.msg_iov = &iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = NULL;
+ msg.msg_controllen = 0;
+
+ pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
+
+ while (1) {
+ iov.iov_base = &packet;
+ iov.iov_len = sizeof(packet);
+
+ ret = recvmsg(sock, &msg, 0);
+ if (ret <= 0) {
+ printf("terminating receiver thread\n");
+ return NULL;
+ }
+
+ clock_gettime(CLOCK_MONOTONIC, &rx_date);
+ stats.rtt = rx_date.tv_sec * 1000000000LL + rx_date.tv_nsec;
+ stats.rtt -= packet.tx_date.tv_sec * 1000000000LL +
+ packet.tx_date.tv_nsec;
+ stats.addr = addr.sin_addr;
+
+ mq_send(mq, (char *)&stats, sizeof(stats), 0);
+ }
+}
+
+
+int main(int argc, char *argv[])
+{
+ struct sched_param param = { .sched_priority = 1 };
+ struct sockaddr_in local_addr;
+ int add_rtskbs = DEFAULT_ADD_BUFFERS;
+ pthread_attr_t thattr;
+ char mqname[32];
+ struct mq_attr mqattr;
+ int stations = 0;
+ int ret;
+
+
+ while (1) {
+ switch (getopt(argc, argv, "d:l:c:b:")) {
+ case 'd':
+ dest_ip_s = optarg;
+ break;
+
+ case 'l':
+ local_ip_s = optarg;
+ break;
+
+ case 'c':
+ cycle = atoi(optarg);
+ break;
+
+ case 'b':
+ add_rtskbs = atoi(optarg);
+
+ case -1:
+ goto end_of_opt;
+
+ default:
+ printf("usage: %s [-d <dest_ip>] [-l <local_ip>] "
+ "[-c <cycle_microsecs>] [-b <add_buffers>]\n",
+ argv[0]);
+ return 0;
+ }
+ }
+ end_of_opt:
+
+ dest_addr.sin_family = AF_INET;
+ dest_addr.sin_port = htons(XMT_PORT);
+ if (dest_ip_s[0])
+ inet_aton(dest_ip_s, &dest_addr.sin_addr);
+ else
+ dest_addr.sin_addr.s_addr = INADDR_ANY;
+
+ if (local_ip_s[0])
+ inet_aton(local_ip_s, &local_addr.sin_addr);
+ else
+ local_addr.sin_addr.s_addr = INADDR_ANY;
+
+ printf("destination ip address: %s = %08x\n",
+ dest_ip_s[0] ? dest_ip_s : "SENDER", dest_addr.sin_addr.s_addr);
+ printf("local ip address: %s = %08x\n",
+ local_ip_s[0] ? local_ip_s : "INADDR_ANY", local_addr.sin_addr.s_addr);
+ printf("cycle: %d us\n", cycle);
+
+ /* create rt-socket */
+ if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+ perror("socket cannot be created");
+ return 1;
+ }
+
+ /* bind the rt-socket to local_addr */
+ local_addr.sin_family = AF_INET;
+ local_addr.sin_port = htons(RCV_PORT);
+ if (bind(sock, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0) {
+ perror("cannot bind to local ip/port");
+ close(sock);
+ return 1;
+ }
+
+ /* extend the socket pool */
+ ret = ioctl(sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs);
+ if (ret < 0)
+ perror("ioctl(RTNET_RTIOC_EXTPOOL)");
+
+ /* create statistics message queue */
+ snprintf(mqname, sizeof(mqname), "/rtt-sender-%d", getpid());
+ mqattr.mq_flags = 0;
+ mqattr.mq_maxmsg = 100;
+ mqattr.mq_msgsize = sizeof(struct packet_stats);
+ mq = mq_open(mqname, O_RDWR | O_CREAT | O_EXCL, 0600, &mqattr);
+ if (mq == (mqd_t)-1) {
+ perror("opening mqueue failed");
+ close(sock);
+ return 1;
+ }
+
+ /* create transmitter rt-thread */
+ pthread_attr_init(&thattr);
+ pthread_attr_setdetachstate(&thattr, PTHREAD_CREATE_JOINABLE);
+ pthread_attr_setstacksize(&thattr, PTHREAD_STACK_MIN);
+ ret = pthread_create(&recv_thread, &thattr, &receiver, NULL);
+ if (ret) {
+ errno = ret; perror("pthread_create(receiver) failed");
+ close(sock);
+ mq_close(mq);
+ return 1;
+ }
+
+ /* create receiver rt-thread */
+ ret = pthread_create(&xmit_thread, &thattr, &transmitter, NULL);
+ if (ret) {
+ errno = ret; perror("pthread_create(transmitter) failed");
+ close(sock);
+ mq_close(mq);
+ pthread_kill(recv_thread, SIGHUP);
+ pthread_join(recv_thread, NULL);
+ return 1;
+ }
+
+ pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m);
+
+ while (1) {
+ struct packet_stats pack;
+ struct station_stats *pstat;
+ int nr;
+
+ ret = mq_receive(mq, (char *)&pack, sizeof(pack), NULL);
+ if (ret < (int)sizeof(pack))
+ break;
+
+ pstat = lookup_stats(pack.addr);
+ if (!pstat)
+ continue;
+
+ pstat->last = pack.rtt;
+ if (pstat->last < pstat->min)
+ pstat->min = pstat->last;
+ if (pstat->last > pstat->max)
+ pstat->max = pstat->last;
+ pstat->count++;
+
+ nr = pstat - &station[0];
+ if (nr >= stations) {
+ stations = nr+1;
+ printf("\n");
+ }
+
+ printf("\033[%dA%s\t%9.3f us, min=%9.3f us, max=%9.3f us, count=%ld\n",
+ stations-nr, inet_ntoa(pack.addr), (float)pstat->last/1000,
+ (float)pstat->min/1000, (float)pstat->max/1000, pstat->count);
+ for (nr = stations-nr-1; nr > 0; nr --)
+ printf("\n");
+ }
+
+ /* This call also leaves primary mode, required for socket cleanup. */
+ printf("shutting down\n");
+
+ pthread_join(xmit_thread, NULL);
+ pthread_kill(recv_thread, SIGHUP);
+ pthread_join(recv_thread, NULL);
+
+ return 0;
+}
diff --git a/demo/net/rttcp-client.c b/demo/net/rttcp-client.c
new file mode 100644
index 000000000..e7da36b91
--- /dev/null
+++ b/demo/net/rttcp-client.c
@@ -0,0 +1,212 @@
+/***
+ *
+ * examples/xenomai/posix/rttcp-client.c
+ *
+ * Simple RTNet TCP client - sends packet to a server
+ *
+ * Copyright (C) 2009 Vladimir Zapolskiy <vladimir.zapolskiy@siemens.com>
+ *
+ * RTnet - real-time networking example
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/mman.h>
+#include <arpa/inet.h>
+#include <limits.h>
+
+#include <rtdm/net.h>
+
+char *dest_ip_s = "127.0.0.1";
+char *local_ip_s = "";
+unsigned int cycle = 500000; /* 500 ms */
+
+#define RCV_PORT 35999
+#define XMT_PORT 36000
+#define DEFAULT_LOOPS 10
+#define DEFAULT_ADD_BUFFERS 30
+
+int add_rtskbs = DEFAULT_ADD_BUFFERS;
+
+pthread_t sender_task = 0;
+
+struct conn_t {
+ int nloops;
+ int sock;
+ struct sockaddr_in dest_addr;
+ struct sockaddr_in local_addr;
+};
+
+const char msg[] = "Hello";
+
+static void *sender(void *arg)
+{
+ struct conn_t *connection = (struct conn_t *)arg;
+ int sock = connection->sock;
+ int ret, i, sopt_len;
+ struct timeval tv;
+ struct timespec sleep_period;
+
+ sopt_len = 1;
+ if ((ret = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &sopt_len,
+ sizeof(sopt_len))) < 0) {
+ perror("set SO_KEEPALIVE socket option");
+ return NULL;
+ }
+
+ tv.tv_sec = 0;
+ tv.tv_usec = 100000;
+ if ((ret = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv,
+ sizeof(tv))) < 0) {
+ perror("set SO_SNDTIMEO socket option");
+ return NULL;
+ }
+
+ if ((ret = bind(sock, (struct sockaddr*)&connection->local_addr,
+ sizeof(struct sockaddr_in))) < 0)
+ {
+ perror("bind socket");
+ return NULL;
+ }
+
+ if ((ret = connect(sock, (struct sockaddr*)&connection->dest_addr,
+ sizeof(struct sockaddr_in))) < 0)
+ {
+ perror("connect to server");
+ return NULL;
+ }
+
+ sleep_period.tv_nsec = cycle * 1000;
+
+ for (i = 1; i <= connection->nloops; i++) {
+ clock_gettime(CLOCK_MONOTONIC, &sleep_period);
+
+ sleep_period.tv_nsec += cycle * 1000;
+ if (sleep_period.tv_nsec >= 1000000000) {
+ sleep_period.tv_nsec = 0;
+ sleep_period.tv_sec++;
+ }
+
+ ret = write(sock, msg, sizeof(msg));
+ if (ret <= 0) {
+ if (ret == 0)
+ printf("connection closed by peer\n");
+ else
+ perror("write to socket");
+ return NULL;
+ }
+ printf("%d: wrote %d bytes to socket\n", i, ret);
+
+ clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &sleep_period, NULL);
+ }
+
+ return NULL;
+}
+
+int main(int argc, char** argv)
+{
+ struct conn_t connection = { .nloops = DEFAULT_LOOPS };
+ struct sched_param param;
+ pthread_attr_t attr;
+ int local_port = RCV_PORT;
+ int ret;
+
+ while (1) {
+ switch (getopt(argc, argv, "d:l:p:n:")) {
+ case 'd':
+ dest_ip_s = optarg;
+ break;
+
+ case 'l':
+ local_ip_s = optarg;
+ break;
+
+ case 'p':
+ local_port = atoi(optarg);
+ break;
+
+ case 'n':
+ connection.nloops = atoi(optarg);
+ break;
+
+ case -1:
+ goto end_of_opt;
+
+ default:
+ printf("usage: %s [-d <dest_ip>] [-l <local_ip>] "
+ "[-p <local port>] [-n <number of loops>]\n", argv[0]);
+ return 0;
+ }
+ }
+ end_of_opt:
+
+ connection.dest_addr.sin_family = AF_INET;
+ connection.dest_addr.sin_port = htons(XMT_PORT);
+ if (dest_ip_s[0])
+ inet_aton(dest_ip_s, &connection.dest_addr.sin_addr);
+ else
+ connection.dest_addr.sin_addr.s_addr = INADDR_ANY;
+
+ connection.local_addr.sin_family = AF_INET;
+ connection.local_addr.sin_port = htons(local_port);
+ if (local_ip_s[0])
+ inet_aton(local_ip_s, &connection.local_addr.sin_addr);
+ else
+ connection.local_addr.sin_addr.s_addr = INADDR_ANY;
+
+ printf("destination ip address: %s = %08x\n",
+ dest_ip_s[0] ? dest_ip_s : "SENDER",
+ connection.dest_addr.sin_addr.s_addr);
+ printf("local ip address: %s = %08x\n",
+ local_ip_s[0] ? local_ip_s : "INADDR_ANY",
+ connection.local_addr.sin_addr.s_addr);
+ printf("port: %d\n", local_port);
+
+ /* create rt-socket */
+ if ((connection.sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+ perror("socket create");
+ return 1;
+ }
+
+ /* extend the socket pool (optional, will fail with non-RT sockets) */
+ ret = ioctl(connection.sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs);
+ if (ret < 0)
+ perror("ioctl(RTNET_RTIOC_EXTPOOL)");
+
+ pthread_attr_init(&attr);
+ pthread_attr_setinheritsched(&attr, 1);
+ pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+ pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
+ param.sched_priority = 80;
+ pthread_attr_setschedparam(&attr, ¶m);
+
+ ret = pthread_create(&sender_task, &attr, &sender, &connection);
+ if (ret) {
+ perror("start real-time task");
+ return 1;
+ }
+
+ pthread_join(sender_task, NULL);
+ close(connection.sock);
+
+ return 0;
+}
diff --git a/demo/net/rttcp-server.c b/demo/net/rttcp-server.c
new file mode 100644
index 000000000..d6422e60e
--- /dev/null
+++ b/demo/net/rttcp-server.c
@@ -0,0 +1,181 @@
+/***
+ *
+ * examples/xenomai/posix/rttcp-server.c
+ *
+ * Simple RTNet TCP server - listens and sends back a packet
+ *
+ * Copyright (C) 2009 Vladimir Zapolskiy <vladimir.zapolskiy@siemens.com>
+ *
+ * RTnet - real-time networking example
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/mman.h>
+#include <arpa/inet.h>
+#include <limits.h>
+
+#include <rtdm/net.h>
+
+char *local_ip_s = "";
+
+#define RCV_PORT 36000
+#define MAX_STRLENGTH 128
+#define DEFAULT_ADD_BUFFERS 30
+
+int add_rtskbs = DEFAULT_ADD_BUFFERS;
+
+pthread_t receiver_task = 0;
+
+struct conn_t {
+ int sock;
+ struct sockaddr_in client_addr;
+ struct sockaddr_in local_addr;
+};
+
+static void* receiver(void* arg)
+{
+ struct conn_t *connection = (struct conn_t*)arg;
+ socklen_t len = sizeof(struct sockaddr_in);
+ int sock = connection->sock;
+ struct timeval tv;
+ fd_set readset;
+ int cnt = 0;
+ char chr;
+ int ret;
+
+ /* bind the rt-socket to local_addr */
+ connection->local_addr.sin_family = AF_INET;
+ connection->local_addr.sin_port = htons(RCV_PORT);
+ if (bind(sock, (struct sockaddr *)&connection->local_addr,
+ sizeof(struct sockaddr_in)) < 0) {
+ perror("bind socket");
+ return NULL;
+ }
+
+ /* Backlog is ignored, current realization just transmit state to LISTEN */
+ if (listen(sock, 1) < 0) {
+ perror("listen on socket");
+ return NULL;
+ }
+
+ /* Warning, no new socket descriptor, only one connection */
+ sock = accept(sock, (struct sockaddr *)&connection->client_addr, &len);
+ if (sock < 0) {
+ perror("accept connection");
+ return NULL;
+ }
+ printf("connection from %s:%d\n",
+ inet_ntoa(connection->client_addr.sin_addr),
+ ntohs(connection->client_addr.sin_port));
+
+ while (1) {
+ FD_ZERO(&readset);
+ FD_SET(sock, &readset);
+ tv.tv_sec = 5;
+ tv.tv_usec = 0;
+
+ ret = select(sock + 1, &readset, NULL, NULL, &tv);
+ if (ret <= 0) {
+ if (ret == 0)
+ fprintf(stderr, "timeout during select()\n");
+ else
+ perror("error on select()");
+ return NULL;
+ }
+
+ if (FD_ISSET(sock, &readset)) {
+ ret = read(sock, &chr, 1);
+ if (ret <= 0) {
+ if (ret == 0)
+ printf("connection closed\n");
+ else
+ perror("error on read()");
+ return NULL;
+ }
+
+ printf("%d: received %d bytes, message: %c\n", cnt++, ret, chr);
+ }
+ }
+ return NULL;
+}
+
+int main(int argc, char** argv)
+{
+ struct conn_t connection;
+ struct sched_param param;
+ pthread_attr_t attr;
+ int ret;
+
+ while (1) {
+ switch (getopt(argc, argv, "l:")) {
+ case 'l':
+ local_ip_s = optarg;
+ break;
+
+ case -1:
+ goto end_of_opt;
+
+ default:
+ printf("usage: %s [-l <local_ip>]\n", argv[0]);
+ return 0;
+ }
+ }
+ end_of_opt:
+
+ if (local_ip_s[0])
+ inet_aton(local_ip_s, &connection.local_addr.sin_addr);
+ else
+ connection.local_addr.sin_addr.s_addr = INADDR_ANY;
+
+ printf("local ip address: %s = %08x\n",
+ local_ip_s[0] ? local_ip_s : "INADDR_ANY",
+ connection.local_addr.sin_addr.s_addr);
+
+ /* create rt-socket */
+ if ((connection.sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+ perror("socket create");
+ return 1;
+ }
+
+ /* extend the socket pool (optional, will fail with non-RT sockets) */
+ ret = ioctl(connection.sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs);
+ if (ret < 0)
+ perror("ioctl(RTNET_RTIOC_EXTPOOL)");
+
+ pthread_attr_init(&attr);
+ pthread_attr_setinheritsched(&attr, 1);
+ pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+ pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
+ param.sched_priority = 20;
+ pthread_attr_setschedparam(&attr, ¶m);
+
+ ret = pthread_create(&receiver_task, NULL, &receiver, &connection);
+ if (ret) {
+ perror("start real-time task");
+ return 1;
+ }
+
+ pthread_join(receiver_task, NULL);
+ close(connection.sock);
+
+ return 0;
+}
diff --git a/demo/net/udp-send.c b/demo/net/udp-send.c
new file mode 100644
index 000000000..a29f98024
--- /dev/null
+++ b/demo/net/udp-send.c
@@ -0,0 +1,136 @@
+/*
+ * sender.c -- multicasts "hello, world!" to a multicast group once a second
+ *
+ * Antony Courtney, 25/11/94
+ */
+
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <error.h>
+#include <stdlib.h>
+#include <sched.h>
+#include <pthread.h>
+#include <sys/timerfd.h>
+#include <boilerplate/trace.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+
+#define HELLO_PORT 12345
+#define HELLO_GROUP "225.0.0.37"
+#define ONE_BILLION 1000000000
+
+#define check_pthread(expr) \
+ ({ \
+ int __e = (expr); \
+ if (__e) { \
+ printf("%s: %d\n", #expr, __e); \
+ exit(EXIT_FAILURE); \
+ } \
+ })
+
+int main(int argc, char *argv[])
+{
+ struct sockaddr_in addr;
+ int fd, tfd, err;
+ char message[] = "Hello, World!\n";
+ struct timespec last_print, start, now;
+ struct sched_param sparm;
+ unsigned long long diff, min = ~0ULL, max = 0, sum, count;
+ struct itimerspec timer_conf;
+
+ /* create what looks like an ordinary UDP socket */
+ if ((fd=socket(AF_INET,SOCK_DGRAM,0)) < 0) {
+ perror("socket");
+ exit(1);
+ }
+
+ if (argc != 2) {
+ fprintf(stderr, "Local ip address expected as first and only argument\n");
+ exit(1);
+ }
+
+ memset(&addr,0,sizeof(addr));
+ addr.sin_family=AF_INET;
+ addr.sin_addr.s_addr=inet_addr(argv[1]); /* N.B.: differs from sender */
+ addr.sin_port=htons(HELLO_PORT);
+
+ /* bind to receive address */
+ if (bind(fd,(struct sockaddr *) &addr,sizeof(addr)) < 0) {
+ perror("bind");
+ exit(1);
+ }
+
+ /* set up destination address */
+ memset(&addr,0,sizeof(addr));
+ addr.sin_family=AF_INET;
+ addr.sin_addr.s_addr=inet_addr(HELLO_GROUP);
+ addr.sin_port=htons(HELLO_PORT);
+
+ sparm.sched_priority = 99;
+
+ check_pthread(pthread_setschedparam(pthread_self(), SCHED_FIFO, &sparm));
+
+ tfd = timerfd_create(CLOCK_MONOTONIC, 0);
+ if (tfd == -1)
+ error(1, errno, "timerfd_create()");
+
+ check_pthread(pthread_setmode_np(0, PTHREAD_WARNSW, NULL));
+
+ /* now just sendto() our destination! */
+ sum = 0;
+ count = 0;
+ err = clock_gettime(CLOCK_MONOTONIC, &start);
+ start.tv_nsec += 1000000;
+ if (start.tv_nsec > ONE_BILLION) {
+ start.tv_nsec -= ONE_BILLION;
+ start.tv_sec++;
+ }
+ timer_conf.it_value = start;
+ timer_conf.it_interval.tv_sec = 0;
+ timer_conf.it_interval.tv_nsec = 5000000;
+ err = timerfd_settime(tfd, TFD_TIMER_ABSTIME, &timer_conf, NULL);
+ if (err)
+ error(1, errno, "timerfd_settime()");
+ clock_gettime(CLOCK_MONOTONIC, &last_print);
+
+ while (1) {
+ uint64_t ticks;
+ clock_gettime(CLOCK_MONOTONIC, &start);
+ if (sendto(fd,message,sizeof(message),0,(struct sockaddr *) &addr,
+ sizeof(addr)) < 0) {
+ perror("sendto");
+ exit(1);
+ }
+ clock_gettime(CLOCK_MONOTONIC, &now);
+
+ diff = now.tv_sec * 1000000ULL + now.tv_nsec / 1000 -
+ (start.tv_sec * 1000000ULL + start.tv_nsec / 1000);
+ if (diff < min)
+ min = diff;
+ if (diff > max) {
+ xntrace_user_freeze(diff, 0);
+ max = diff;
+ }
+ sum += diff;
+ count++;
+
+ diff = now.tv_sec * 1000000ULL + now.tv_nsec / 1000 -
+ (last_print.tv_sec * 1000000ULL + last_print.tv_sec / 1000);
+ if (diff >= 1000000) {
+ fprintf(stderr, "%Lu, %Lu, %Lu\n",
+ min, sum / count, max);
+ last_print = now;
+ }
+
+ err = read(tfd, &ticks, sizeof(ticks));
+ if (err < 0)
+ error(1, errno, "read()");
+ }
+}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 18/31] net/stack: increase maximum number of ethernet devices
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (16 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 17/31] demo/net: add rtnet tests Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 19/31] utils/net: ping: display min and average round-trip time Jean-Baptiste Trédez
` (14 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>
Each VLAN registers a (virtual) device.
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/include/rtdev.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/drivers/net/stack/include/rtdev.h b/kernel/drivers/net/stack/include/rtdev.h
index 27c390df5..77f142174 100644
--- a/kernel/drivers/net/stack/include/rtdev.h
+++ b/kernel/drivers/net/stack/include/rtdev.h
@@ -26,7 +26,7 @@
#ifndef __RTDEV_H_
#define __RTDEV_H_
-#define MAX_RT_DEVICES 8
+#define MAX_RT_DEVICES 32
#ifdef __KERNEL__
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 19/31] utils/net: ping: display min and average round-trip time
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (17 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 18/31] net/stack: increase maximum number of ethernet devices Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 20/31] net/drivers: fec: rebase over original driver from kernel 4.14.85 Jean-Baptiste Trédez
` (13 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Christophe Carton <christophe.carton@ixblue.com>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
utils/net/rtping.c | 16 +++++++++++-----
1 file changed, 11 insertions(+), 5 deletions(-)
diff --git a/utils/net/rtping.c b/utils/net/rtping.c
index bdaf6cb15..878fa6dce 100644
--- a/utils/net/rtping.c
+++ b/utils/net/rtping.c
@@ -29,6 +29,7 @@
#include <signal.h>
#include <string.h>
#include <unistd.h>
+#include <float.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
@@ -46,7 +47,9 @@ unsigned int count = 0;
int delay = 1000;
unsigned int sent = 0;
unsigned int received = 0;
-float wc_rtt = 0;
+float max_rtt = FLT_MIN;
+float min_rtt = FLT_MAX;
+float avr_rtt = 0.0f;
void help(void)
@@ -81,9 +84,9 @@ void print_statistics()
{
printf("\n--- %s rtping statistics ---\n"
"%d packets transmitted, %d received, %d%% packet loss\n"
- "worst case rtt = %.1f us\n",
+ "rtt min/avg/max = %.1f/%.1f/%.1f us\n",
inet_ntoa(addr), sent, received, 100 - ((received * 100) / sent),
- wc_rtt);
+ min_rtt, avr_rtt/received, max_rtt);
exit(0);
}
@@ -117,8 +120,11 @@ void ping(int signal)
received++;
from.s_addr = cmd.args.ping.ip_addr;
rtt = (float)cmd.args.ping.rtt / (float)1000;
- if (rtt > wc_rtt)
- wc_rtt = rtt;
+ if (rtt > max_rtt)
+ max_rtt = rtt;
+ if (rtt < min_rtt)
+ min_rtt = rtt;
+ avr_rtt += rtt;
printf("%d bytes from %s: icmp_seq=%d time=%.1f us\n",
ret, inet_ntoa(from), cmd.args.ping.sequence, rtt);
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 20/31] net/drivers: fec: rebase over original driver from kernel 4.14.85
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (18 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 19/31] utils/net: ping: display min and average round-trip time Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 21/31] net/drivers: fec: enable multicast Jean-Baptiste Trédez
` (12 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
This driver has three runtime modes:
- full RTnet mode for all devices (default)
- partial RTnet. RTnet mode only for devices which do not define/set
the boolean "rtnet-disabled" to true in the dts. The latter are
operated normally, interfacing with the standard network stack
instead of RTnet.
- full regular operations. RTnet mode disabled for all devices if the
"rtnet_disabled" module parameter is set to non-zero/true. In this
configuration, the driver operates all devices like the original
driver does, via the standard network stack.
In addition, the PHC device attached to the FEC is still available to
the PTP stack, including when the driver operates devices in RTnet
mode. There is no real-time guarantee though.
Tested on i.MX6Q.
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/drivers/Kconfig | 9 +
kernel/drivers/net/drivers/Makefile | 6 +-
kernel/drivers/net/drivers/fec.c | 1859 -------
kernel/drivers/net/drivers/freescale/Makefile | 5 +
kernel/drivers/net/drivers/freescale/fec.h | 610 +++
.../drivers/net/drivers/freescale/fec_main.c | 4394 +++++++++++++++++
.../drivers/net/drivers/freescale/fec_ptp.c | 640 +++
kernel/drivers/net/drivers/rt_fec.h | 153 -
8 files changed, 5660 insertions(+), 2016 deletions(-)
delete mode 100644 kernel/drivers/net/drivers/fec.c
create mode 100644 kernel/drivers/net/drivers/freescale/Makefile
create mode 100644 kernel/drivers/net/drivers/freescale/fec.h
create mode 100644 kernel/drivers/net/drivers/freescale/fec_main.c
create mode 100644 kernel/drivers/net/drivers/freescale/fec_ptp.c
delete mode 100644 kernel/drivers/net/drivers/rt_fec.h
diff --git a/kernel/drivers/net/drivers/Kconfig b/kernel/drivers/net/drivers/Kconfig
index 6889a500d..c36533479 100644
--- a/kernel/drivers/net/drivers/Kconfig
+++ b/kernel/drivers/net/drivers/Kconfig
@@ -131,6 +131,15 @@ config XENO_DRIVERS_NET_DRV_MACB
Driver for internal MAC-controller on AT91SAM926x microcontrollers.
Porting by Cristiano Mantovani and Stefano Banzi (Marposs SpA).
+config XENO_DRIVERS_NET_FEC
+ depends on XENO_DRIVERS_NET
+ tristate "Freescale FEC"
+ depends on ARCH_MXC || SOC_IMX28
+ select PHYLIB
+ imply PTP_1588_CLOCK
+ ---help---
+ For built-in 10/100 Fast ethernet controller on Freescale i.MX
+ processors.
endif
source "drivers/xenomai/net/drivers/experimental/Kconfig"
diff --git a/kernel/drivers/net/drivers/Makefile b/kernel/drivers/net/drivers/Makefile
index d97d5591c..03f475fd6 100644
--- a/kernel/drivers/net/drivers/Makefile
+++ b/kernel/drivers/net/drivers/Makefile
@@ -12,6 +12,8 @@ obj-$(CONFIG_XENO_DRIVERS_NET_DRV_TULIP) += tulip/
obj-$(CONFIG_XENO_DRIVERS_NET_DRV_IGB) += igb/
+obj-$(CONFIG_XENO_DRIVERS_NET_FEC) += freescale/
+
obj-$(CONFIG_XENO_DRIVERS_NET_DRV_8139) += rt_8139too.o
rt_8139too-y := 8139too.o
@@ -40,10 +42,6 @@ obj-$(CONFIG_XENO_DRIVERS_NET_DRV_FEC_ENET) += rt_mpc8xx_fec.o
rt_mpc8xx_fec-y := mpc8xx_fec.o
-obj-$(CONFIG_XENO_DRIVERS_NET_DRV_FEC) += rt_fec.o
-
-rt_fec-y := fec.o
-
obj-$(CONFIG_XENO_DRIVERS_NET_DRV_NATSEMI) += rt_natsemi.o
rt_natsemi-y := natsemi.o
diff --git a/kernel/drivers/net/drivers/fec.c b/kernel/drivers/net/drivers/fec.c
deleted file mode 100644
index d94ec690f..000000000
--- a/kernel/drivers/net/drivers/fec.c
+++ /dev/null
@@ -1,1859 +0,0 @@
-/*
- * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
- * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
- *
- * Right now, I am very wasteful with the buffers. I allocate memory
- * pages and then divide them into 2K frame buffers. This way I know I
- * have buffers large enough to hold one frame within one buffer descriptor.
- * Once I get this working, I will use 64 or 128 byte CPM buffers, which
- * will be much more memory efficient and will easily handle lots of
- * small packets.
- *
- * Much better multiple PHY support by Magnus Damm.
- * Copyright (c) 2000 Ericsson Radio Systems AB.
- *
- * Support for FEC controller of ColdFire processors.
- * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
- *
- * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
- * Copyright (c) 2004-2006 Macq Electronique SA.
- *
- * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
- *
- * Ported from v3.5 Linux drivers/net/ethernet/freescale/fec.[ch]
- * (git tag v3.5-709-ga6be1fc)
- *
- * Copyright (c) 2012 Wolfgang Grandegger <wg@denx.de>
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/version.h>
-#include <linux/string.h>
-#include <linux/ptrace.h>
-#include <linux/errno.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/pci.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/spinlock.h>
-#include <linux/workqueue.h>
-#include <linux/bitops.h>
-#include <linux/io.h>
-#include <linux/irq.h>
-#include <linux/clk.h>
-#include <linux/platform_device.h>
-#include <linux/phy.h>
-#include <linux/fec.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include <linux/of_gpio.h>
-#include <linux/of_net.h>
-#include <linux/pinctrl/consumer.h>
-
-#include <asm/cacheflush.h>
-
-#ifndef CONFIG_ARM
-#include <asm/coldfire.h>
-#include <asm/mcfsim.h>
-#endif
-
-/* RTnet */
-#include <rtnet_port.h>
-#include <rtskb.h>
-
-/* RTnet */
-#include "rt_fec.h"
-
-MODULE_AUTHOR("Maintainer: Wolfgang Grandegger <wg@denx.de>");
-MODULE_DESCRIPTION("RTnet driver for the FEC Ethernet");
-MODULE_LICENSE("GPL");
-
-#if defined(CONFIG_ARM)
-#define FEC_ALIGNMENT 0xf
-#else
-#define FEC_ALIGNMENT 0x3
-#endif
-
-#define DRIVER_NAME "rt_fec"
-
-/* Controller is ENET-MAC */
-#define FEC_QUIRK_ENET_MAC (1 << 0)
-/* Controller needs driver to swap frame */
-#define FEC_QUIRK_SWAP_FRAME (1 << 1)
-/* Controller uses gasket */
-#define FEC_QUIRK_USE_GASKET (1 << 2)
-/* Controller has GBIT support */
-#define FEC_QUIRK_HAS_GBIT (1 << 3)
-
-static struct platform_device_id fec_devtype[] = {
- {
- .name = "fec",
-/* For legacy not devicetree based support */
-#if defined(CONFIG_SOC_IMX6Q)
- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT,
-#elif defined(CONFIG_SOC_IMX28)
- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME,
-#elif defined(CONFIG_SOC_IMX25)
- .driver_data = FEC_QUIRK_USE_GASKET,
-#else
- /* keep it for coldfire */
- .driver_data = 0,
-#endif
- }, {
- .name = "imx25-fec",
- .driver_data = FEC_QUIRK_USE_GASKET,
- }, {
- .name = "imx27-fec",
- .driver_data = 0,
- }, {
- .name = "imx28-fec",
- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME,
- }, {
- .name = "imx6q-fec",
- .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT,
- }, {
- /* sentinel */
- }
-};
-MODULE_DEVICE_TABLE(platform, fec_devtype);
-
-enum imx_fec_type {
- IMX25_FEC = 1, /* runs on i.mx25/50/53 */
- IMX27_FEC, /* runs on i.mx27/35/51 */
- IMX28_FEC,
- IMX6Q_FEC,
-};
-
-static const struct of_device_id fec_dt_ids[] = {
- { .compatible = "fsl,imx25-fec", .data = &fec_devtype[IMX25_FEC], },
- { .compatible = "fsl,imx27-fec", .data = &fec_devtype[IMX27_FEC], },
- { .compatible = "fsl,imx28-fec", .data = &fec_devtype[IMX28_FEC], },
- { .compatible = "fsl,imx6q-fec", .data = &fec_devtype[IMX6Q_FEC], },
- { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, fec_dt_ids);
-
-static unsigned char macaddr[ETH_ALEN];
-module_param_array(macaddr, byte, NULL, 0);
-MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
-
-#if defined(CONFIG_M5272)
-/*
- * Some hardware gets it MAC address out of local flash memory.
- * if this is non-zero then assume it is the address to get MAC from.
- */
-#if defined(CONFIG_NETtel)
-#define FEC_FLASHMAC 0xf0006006
-#elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
-#define FEC_FLASHMAC 0xf0006000
-#elif defined(CONFIG_CANCam)
-#define FEC_FLASHMAC 0xf0020000
-#elif defined (CONFIG_M5272C3)
-#define FEC_FLASHMAC (0xffe04000 + 4)
-#elif defined(CONFIG_MOD5272)
-#define FEC_FLASHMAC 0xffc0406b
-#else
-#define FEC_FLASHMAC 0
-#endif
-#endif /* CONFIG_M5272 */
-
-/* The number of Tx and Rx buffers. These are allocated from the page
- * pool. The code may assume these are power of two, so it it best
- * to keep them that size.
- * We don't need to allocate pages for the transmitter. We just use
- * the skbuffer directly.
- */
-#define FEC_ENET_RX_PAGES 8
-#define FEC_ENET_RX_FRSIZE RTSKB_SIZE /* Maximum size for RTnet */
-#define FEC_ENET_RX_FRPPG (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
-#define RX_RING_SIZE (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
-#define FEC_ENET_TX_FRSIZE 2048
-#define FEC_ENET_TX_FRPPG (PAGE_SIZE / FEC_ENET_TX_FRSIZE)
-#define TX_RING_SIZE 16 /* Must be power of two */
-#define TX_RING_MOD_MASK 15 /* for this to work */
-
-#if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
-#error "FEC: descriptor ring size constants too large"
-#endif
-
-/* Interrupt events/masks. */
-#define FEC_ENET_HBERR ((uint)0x80000000) /* Heartbeat error */
-#define FEC_ENET_BABR ((uint)0x40000000) /* Babbling receiver */
-#define FEC_ENET_BABT ((uint)0x20000000) /* Babbling transmitter */
-#define FEC_ENET_GRA ((uint)0x10000000) /* Graceful stop complete */
-#define FEC_ENET_TXF ((uint)0x08000000) /* Full frame transmitted */
-#define FEC_ENET_TXB ((uint)0x04000000) /* A buffer was transmitted */
-#define FEC_ENET_RXF ((uint)0x02000000) /* Full frame received */
-#define FEC_ENET_RXB ((uint)0x01000000) /* A buffer was received */
-#define FEC_ENET_MII ((uint)0x00800000) /* MII interrupt */
-#define FEC_ENET_EBERR ((uint)0x00400000) /* SDMA bus error */
-
-#define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII)
-
-/* The FEC stores dest/src/type, data, and checksum for receive packets.
- */
-#define PKT_MAXBUF_SIZE 1518
-#define PKT_MINBUF_SIZE 64
-#define PKT_MAXBLR_SIZE 1520
-
-/* This device has up to three irqs on some platforms */
-#define FEC_IRQ_NUM 3
-
-/*
- * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
- * size bits. Other FEC hardware does not, so we need to take that into
- * account when setting it.
- */
-#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
- defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
-#define OPT_FRAME_SIZE (PKT_MAXBUF_SIZE << 16)
-#else
-#define OPT_FRAME_SIZE 0
-#endif
-
-static unsigned int rx_pool_size = 2 * RX_RING_SIZE;
-module_param(rx_pool_size, int, 0444);
-MODULE_PARM_DESC(rx_pool_size, "Receive buffer pool size");
-
-#ifndef rtnetdev_priv
-#define rtnetdev_priv(ndev) (ndev)->priv
-#endif
-
-/* The FEC buffer descriptors track the ring buffers. The rx_bd_base and
- * tx_bd_base always point to the base of the buffer descriptors. The
- * cur_rx and cur_tx point to the currently available buffer.
- * The dirty_tx tracks the current buffer that is being sent by the
- * controller. The cur_tx and dirty_tx are equal under both completely
- * empty and completely full conditions. The empty/ready indicator in
- * the buffer descriptor determines the actual condition.
- */
-struct fec_enet_private {
- /* Hardware registers of the FEC device */
- void __iomem *hwp;
-
- struct net_device *netdev; /* linux netdev needed for phy handling */
-
- struct clk *clk_ipg;
- struct clk *clk_ahb;
-
- /* The saved address of a sent-in-place packet/buffer, for skfree(). */
- unsigned char *tx_bounce[TX_RING_SIZE];
- struct rtskb *tx_skbuff[TX_RING_SIZE];
- struct rtskb *rx_skbuff[RX_RING_SIZE];
- ushort skb_cur;
- ushort skb_dirty;
-
- /* CPM dual port RAM relative addresses */
- dma_addr_t bd_dma;
- /* Address of Rx and Tx buffers */
- struct bufdesc *rx_bd_base;
- struct bufdesc *tx_bd_base;
- /* The next free ring entry */
- struct bufdesc *cur_rx, *cur_tx;
- /* The ring entries to be free()ed */
- struct bufdesc *dirty_tx;
-
- uint tx_full;
- /* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
- rtdm_lock_t hw_lock;
-
- struct platform_device *pdev;
-
- int opened;
- int dev_id;
-
- /* Phylib and MDIO interface */
- struct mii_bus *mii_bus;
- struct phy_device *phy_dev;
- int mii_timeout;
- uint phy_speed;
- phy_interface_t phy_interface;
- int link;
- int full_duplex;
- struct completion mdio_done;
- int irq[FEC_IRQ_NUM];
-
- /* RTnet */
- struct device *dev;
- rtdm_irq_t irq_handle[3];
- rtdm_nrtsig_t mdio_done_sig;
- struct net_device_stats stats;
-};
-
-/* For phy handling */
-struct fec_enet_netdev_priv {
- struct rtnet_device *rtdev;
-};
-
-/* FEC MII MMFR bits definition */
-#define FEC_MMFR_ST (1 << 30)
-#define FEC_MMFR_OP_READ (2 << 28)
-#define FEC_MMFR_OP_WRITE (1 << 28)
-#define FEC_MMFR_PA(v) ((v & 0x1f) << 23)
-#define FEC_MMFR_RA(v) ((v & 0x1f) << 18)
-#define FEC_MMFR_TA (2 << 16)
-#define FEC_MMFR_DATA(v) (v & 0xffff)
-
-#define FEC_MII_TIMEOUT 30000 /* us */
-
-/* Transmitter timeout */
-#define TX_TIMEOUT (2 * HZ)
-
-static int mii_cnt;
-
-static void *swap_buffer(void *bufaddr, int len)
-{
- int i;
- unsigned int *buf = bufaddr;
-
- for (i = 0; i < (len + 3) / 4; i++, buf++)
- *buf = cpu_to_be32(*buf);
-
- return bufaddr;
-}
-
-static int
-fec_enet_start_xmit(struct rtskb *skb, struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- const struct platform_device_id *id_entry =
- platform_get_device_id(fep->pdev);
- struct bufdesc *bdp;
- void *bufaddr;
- unsigned short status;
- unsigned long context;
-
- if (!fep->link) {
- /* Link is down or autonegotiation is in progress. */
- printk("%s: tx link down!.\n", ndev->name);
- rtnetif_stop_queue(ndev);
- return 1; /* RTnet: will call kfree_rtskb() */
- }
-
- rtdm_lock_get_irqsave(&fep->hw_lock, context);
-
- /* RTnet */
- if (skb->xmit_stamp)
- *skb->xmit_stamp = cpu_to_be64(rtdm_clock_read() +
- *skb->xmit_stamp);
-
- /* Fill in a Tx ring entry */
- bdp = fep->cur_tx;
-
- status = bdp->cbd_sc;
-
- if (status & BD_ENET_TX_READY) {
- /* Ooops. All transmit buffers are full. Bail out.
- * This should not happen, since ndev->tbusy should be set.
- */
- printk("%s: tx queue full!.\n", ndev->name);
- rtdm_lock_put_irqrestore(&fep->hw_lock, context);
- return 1; /* RTnet: will call kfree_rtskb() */
- }
-
- /* Clear all of the status flags */
- status &= ~BD_ENET_TX_STATS;
-
- /* Set buffer length and buffer pointer */
- bufaddr = skb->data;
- bdp->cbd_datlen = skb->len;
-
- /*
- * On some FEC implementations data must be aligned on
- * 4-byte boundaries. Use bounce buffers to copy data
- * and get it aligned. Ugh.
- */
- if (((unsigned long) bufaddr) & FEC_ALIGNMENT) {
- unsigned int index;
- index = bdp - fep->tx_bd_base;
- memcpy(fep->tx_bounce[index], skb->data, skb->len);
- bufaddr = fep->tx_bounce[index];
- }
-
- /*
- * Some design made an incorrect assumption on endian mode of
- * the system that it's running on. As the result, driver has to
- * swap every frame going to and coming from the controller.
- */
- if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
- swap_buffer(bufaddr, skb->len);
-
- /* Save skb pointer */
- fep->tx_skbuff[fep->skb_cur] = skb;
-
- fep->stats.tx_bytes += skb->len;
- fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;
-
- /* Push the data cache so the CPM does not get stale memory
- * data.
- */
- bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, bufaddr,
- FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
-
- /* Send it on its way. Tell FEC it's ready, interrupt when done,
- * it's the last BD of the frame, and to put the CRC on the end.
- */
- status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
- | BD_ENET_TX_LAST | BD_ENET_TX_TC);
- bdp->cbd_sc = status;
-
- /* Trigger transmission start */
- writel(0, fep->hwp + FEC_X_DES_ACTIVE);
-
- /* If this was the last BD in the ring, start at the beginning again. */
- if (status & BD_ENET_TX_WRAP)
- bdp = fep->tx_bd_base;
- else
- bdp++;
-
- if (bdp == fep->dirty_tx) {
- fep->tx_full = 1;
- rtnetif_stop_queue(ndev);
- }
-
- fep->cur_tx = bdp;
-
- rtdm_lock_put_irqrestore(&fep->hw_lock, context);
-
- return NETDEV_TX_OK;
-}
-
-/* This function is called to start or restart the FEC during a link
- * change. This only happens when switching between half and full
- * duplex.
- */
-static void
-fec_restart(struct rtnet_device *ndev, int duplex)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- const struct platform_device_id *id_entry =
- platform_get_device_id(fep->pdev);
- int i;
- u32 temp_mac[2];
- u32 rcntl = OPT_FRAME_SIZE | 0x04;
- u32 ecntl = 0x2; /* ETHEREN */
-
- /* Whack a reset. We should wait for this. */
- writel(1, fep->hwp + FEC_ECNTRL);
- udelay(10);
-
- /*
- * enet-mac reset will reset mac address registers too,
- * so need to reconfigure it.
- */
- if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
- memcpy(&temp_mac, ndev->dev_addr, ETH_ALEN);
- writel(cpu_to_be32(temp_mac[0]), fep->hwp + FEC_ADDR_LOW);
- writel(cpu_to_be32(temp_mac[1]), fep->hwp + FEC_ADDR_HIGH);
- }
-
- /* Clear any outstanding interrupt. */
- writel(0xffc00000, fep->hwp + FEC_IEVENT);
-
- /* Reset all multicast. */
- writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
- writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
-#ifndef CONFIG_M5272
- writel(0, fep->hwp + FEC_HASH_TABLE_HIGH);
- writel(0, fep->hwp + FEC_HASH_TABLE_LOW);
-#endif
-
- /* Set maximum receive buffer size. */
- writel(PKT_MAXBLR_SIZE, fep->hwp + FEC_R_BUFF_SIZE);
-
- /* Set receive and transmit descriptor base. */
- writel(fep->bd_dma, fep->hwp + FEC_R_DES_START);
- writel((unsigned long)fep->bd_dma + sizeof(struct bufdesc) * RX_RING_SIZE,
- fep->hwp + FEC_X_DES_START);
-
- fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
- fep->cur_rx = fep->rx_bd_base;
-
- /* Reset SKB transmit buffers. */
- fep->skb_cur = fep->skb_dirty = 0;
- for (i = 0; i <= TX_RING_MOD_MASK; i++) {
- if (fep->tx_skbuff[i]) {
- dev_kfree_rtskb(fep->tx_skbuff[i]);
- fep->tx_skbuff[i] = NULL;
- }
- }
-
- /* Enable MII mode */
- if (duplex) {
- /* FD enable */
- writel(0x04, fep->hwp + FEC_X_CNTRL);
- } else {
- /* No Rcv on Xmit */
- rcntl |= 0x02;
- writel(0x0, fep->hwp + FEC_X_CNTRL);
- }
-
- fep->full_duplex = duplex;
-
- /* Set MII speed */
- writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
-
- /*
- * The phy interface and speed need to get configured
- * differently on enet-mac.
- */
- if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
- /* Enable flow control and length check */
- rcntl |= 0x40000000 | 0x00000020;
-
- /* RGMII, RMII or MII */
- if (fep->phy_interface == PHY_INTERFACE_MODE_RGMII)
- rcntl |= (1 << 6);
- else if (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
- rcntl |= (1 << 8);
- else
- rcntl &= ~(1 << 8);
-
- /* 1G, 100M or 10M */
- if (fep->phy_dev) {
- if (fep->phy_dev->speed == SPEED_1000)
- ecntl |= (1 << 5);
- else if (fep->phy_dev->speed == SPEED_100)
- rcntl &= ~(1 << 9);
- else
- rcntl |= (1 << 9);
- }
- } else {
-#ifdef FEC_MIIGSK_ENR
- if (id_entry->driver_data & FEC_QUIRK_USE_GASKET) {
- u32 cfgr;
- /* disable the gasket and wait */
- writel(0, fep->hwp + FEC_MIIGSK_ENR);
- while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
- udelay(1);
-
- /*
- * configure the gasket:
- * RMII, 50 MHz, no loopback, no echo
- * MII, 25 MHz, no loopback, no echo
- */
- cfgr = (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
- ? BM_MIIGSK_CFGR_RMII : BM_MIIGSK_CFGR_MII;
- if (fep->phy_dev && fep->phy_dev->speed == SPEED_10)
- cfgr |= BM_MIIGSK_CFGR_FRCONT_10M;
- writel(cfgr, fep->hwp + FEC_MIIGSK_CFGR);
-
- /* re-enable the gasket */
- writel(2, fep->hwp + FEC_MIIGSK_ENR);
- }
-#endif
- }
- writel(rcntl, fep->hwp + FEC_R_CNTRL);
-
- if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
- /* enable ENET endian swap */
- ecntl |= (1 << 8);
- /* enable ENET store and forward mode */
- writel(1 << 8, fep->hwp + FEC_X_WMRK);
- }
-
- /* And last, enable the transmit and receive processing */
- writel(ecntl, fep->hwp + FEC_ECNTRL);
- writel(0, fep->hwp + FEC_R_DES_ACTIVE);
-
- /* Enable interrupts we wish to service */
- writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
-}
-
-static void
-fec_stop(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- const struct platform_device_id *id_entry =
- platform_get_device_id(fep->pdev);
- u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8);
-
- /* We cannot expect a graceful transmit stop without link !!! */
- if (fep->link) {
- writel(1, fep->hwp + FEC_X_CNTRL); /* Graceful transmit stop */
- udelay(10);
- if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA))
- printk("fec_stop : Graceful transmit stop did not complete !\n");
- }
-
- /* Whack a reset. We should wait for this. */
- writel(1, fep->hwp + FEC_ECNTRL);
- udelay(10);
- writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
- writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
-
- /* We have to keep ENET enabled to have MII interrupt stay working */
- if (id_entry->driver_data & FEC_QUIRK_ENET_MAC) {
- writel(2, fep->hwp + FEC_ECNTRL);
- writel(rmii_mode, fep->hwp + FEC_R_CNTRL);
- }
-}
-
-static void
-fec_enet_tx(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep;
- struct bufdesc *bdp;
- unsigned short status;
- struct rtskb *skb;
-
- fep = rtnetdev_priv(ndev);
- rtdm_lock_get(&fep->hw_lock);
- bdp = fep->dirty_tx;
-
- while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
- if (bdp == fep->cur_tx && fep->tx_full == 0)
- break;
-
- dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
- FEC_ENET_TX_FRSIZE, DMA_TO_DEVICE);
- bdp->cbd_bufaddr = 0;
-
- skb = fep->tx_skbuff[fep->skb_dirty];
- /* Check for errors. */
- if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
- BD_ENET_TX_RL | BD_ENET_TX_UN |
- BD_ENET_TX_CSL)) {
- fep->stats.tx_errors++;
- if (status & BD_ENET_TX_HB) /* No heartbeat */
- fep->stats.tx_heartbeat_errors++;
- if (status & BD_ENET_TX_LC) /* Late collision */
- fep->stats.tx_window_errors++;
- if (status & BD_ENET_TX_RL) /* Retrans limit */
- fep->stats.tx_aborted_errors++;
- if (status & BD_ENET_TX_UN) /* Underrun */
- fep->stats.tx_fifo_errors++;
- if (status & BD_ENET_TX_CSL) /* Carrier lost */
- fep->stats.tx_carrier_errors++;
- } else {
- fep->stats.tx_packets++;
- }
-
- if (status & BD_ENET_TX_READY)
- printk("HEY! Enet xmit interrupt and TX_READY.\n");
-
- /* Deferred means some collisions occurred during transmit,
- * but we eventually sent the packet OK.
- */
- if (status & BD_ENET_TX_DEF)
- fep->stats.collisions++;
-
- /* Free the sk buffer associated with this last transmit */
- dev_kfree_rtskb(skb); /* RTnet */
- fep->tx_skbuff[fep->skb_dirty] = NULL;
- fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
-
- /* Update pointer to next buffer descriptor to be transmitted */
- if (status & BD_ENET_TX_WRAP)
- bdp = fep->tx_bd_base;
- else
- bdp++;
-
- /* Since we have freed up a buffer, the ring is no longer full
- */
- if (fep->tx_full) {
- fep->tx_full = 0;
- if (rtnetif_queue_stopped(ndev))
- rtnetif_wake_queue(ndev);
- }
- }
- fep->dirty_tx = bdp;
- rtdm_lock_put(&fep->hw_lock);
-}
-
-
-/* During a receive, the cur_rx points to the current incoming buffer.
- * When we update through the ring, if the next incoming buffer has
- * not been given to the system, we just set the empty indicator,
- * effectively tossing the packet.
- */
-static void
-fec_enet_rx(struct rtnet_device *ndev, int *packets, nanosecs_abs_t *time_stamp)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- const struct platform_device_id *id_entry =
- platform_get_device_id(fep->pdev);
- struct bufdesc *bdp;
- unsigned short status;
- struct rtskb *skb;
- ushort pkt_len;
- __u8 *data;
-
-#ifdef CONFIG_M532x
- flush_cache_all();
-#endif
- rtdm_lock_get(&fep->hw_lock);
-
- /* First, grab all of the stats for the incoming packet.
- * These get messed up if we get called due to a busy condition.
- */
- bdp = fep->cur_rx;
-
- while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
-
- /* Since we have allocated space to hold a complete frame,
- * the last indicator should be set.
- */
- if ((status & BD_ENET_RX_LAST) == 0)
- printk("FEC ENET: rcv is not +last\n");
-
- if (!fep->opened)
- goto rx_processing_done;
-
- /* Check for errors. */
- if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
- BD_ENET_RX_CR | BD_ENET_RX_OV)) {
- fep->stats.rx_errors++;
- if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
- /* Frame too long or too short. */
- fep->stats.rx_length_errors++;
- }
- if (status & BD_ENET_RX_NO) /* Frame alignment */
- fep->stats.rx_frame_errors++;
- if (status & BD_ENET_RX_CR) /* CRC Error */
- fep->stats.rx_crc_errors++;
- if (status & BD_ENET_RX_OV) /* FIFO overrun */
- fep->stats.rx_fifo_errors++;
- }
-
- /* Report late collisions as a frame error.
- * On this error, the BD is closed, but we don't know what we
- * have in the buffer. So, just drop this frame on the floor.
- */
- if (status & BD_ENET_RX_CL) {
- fep->stats.rx_errors++;
- fep->stats.rx_frame_errors++;
- goto rx_processing_done;
- }
-
- /* Process the incoming frame. */
- fep->stats.rx_packets++;
- pkt_len = bdp->cbd_datlen;
- fep->stats.rx_bytes += pkt_len;
- data = (__u8*)__va(bdp->cbd_bufaddr);
-
- dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
- FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
-
- if (id_entry->driver_data & FEC_QUIRK_SWAP_FRAME)
- swap_buffer(data, pkt_len);
-
- /* This does 16 byte alignment, exactly what we need.
- * The packet length includes FCS, but we don't want to
- * include that when passing upstream as it messes up
- * bridging applications.
- */
- skb = rtnetdev_alloc_rtskb(ndev, pkt_len - 4 + NET_IP_ALIGN); /* RTnet */
-
- if (unlikely(!skb)) {
- printk("%s: Memory squeeze, dropping packet.\n",
- ndev->name);
- fep->stats.rx_dropped++;
- } else {
- rtskb_reserve(skb, NET_IP_ALIGN);
- rtskb_put(skb, pkt_len - 4); /* Make room */
- memcpy(skb->data, data, pkt_len - 4);
- skb->protocol = rt_eth_type_trans(skb, ndev);
- skb->time_stamp = *time_stamp;
- rtnetif_rx(skb);
- (*packets)++; /* RTnet */
- }
-
- bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, data,
- FEC_ENET_TX_FRSIZE, DMA_FROM_DEVICE);
-rx_processing_done:
- /* Clear the status flags for this buffer */
- status &= ~BD_ENET_RX_STATS;
-
- /* Mark the buffer empty */
- status |= BD_ENET_RX_EMPTY;
- bdp->cbd_sc = status;
-
- /* Update BD pointer to next entry */
- if (status & BD_ENET_RX_WRAP)
- bdp = fep->rx_bd_base;
- else
- bdp++;
- /* Doing this here will keep the FEC running while we process
- * incoming frames. On a heavily loaded network, we should be
- * able to keep up at the expense of system resources.
- */
- writel(0, fep->hwp + FEC_R_DES_ACTIVE);
- }
- fep->cur_rx = bdp;
-
- rtdm_lock_put(&fep->hw_lock);
-}
-
-static int
-fec_enet_interrupt(rtdm_irq_t *irq_handle)
-{
- struct rtnet_device *ndev =
- rtdm_irq_get_arg(irq_handle, struct rtnet_device); /* RTnet */
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- uint int_events;
- irqreturn_t ret = RTDM_IRQ_NONE;
- /* RTnet */
- nanosecs_abs_t time_stamp = rtdm_clock_read();
- int packets = 0;
-
- do {
- int_events = readl(fep->hwp + FEC_IEVENT);
- writel(int_events, fep->hwp + FEC_IEVENT);
-
- if (int_events & FEC_ENET_RXF) {
- ret = RTDM_IRQ_HANDLED;
- fec_enet_rx(ndev, &packets, &time_stamp);
- }
-
- /* Transmit OK, or non-fatal error. Update the buffer
- * descriptors. FEC handles all errors, we just discover
- * them as part of the transmit process.
- */
- if (int_events & FEC_ENET_TXF) {
- ret = RTDM_IRQ_HANDLED;
- fec_enet_tx(ndev);
- }
-
- if (int_events & FEC_ENET_MII) {
- ret = RTDM_IRQ_HANDLED;
- rtdm_nrtsig_pend(&fep->mdio_done_sig);
- }
- } while (int_events);
-
- if (packets > 0)
- rt_mark_stack_mgr(ndev);
-
- return ret;
-}
-
-
-
-/* ------------------------------------------------------------------------- */
-static void __inline__ fec_get_mac(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
- unsigned char *iap, tmpaddr[ETH_ALEN];
-
- /*
- * try to get mac address in following order:
- *
- * 1) module parameter via kernel command line in form
- * fec.macaddr=0x00,0x04,0x9f,0x01,0x30,0xe0
- */
- iap = macaddr;
-
-#ifdef CONFIG_OF
- /*
- * 2) from device tree data
- */
- if (!is_valid_ether_addr(iap)) {
- struct device_node *np = fep->pdev->dev.of_node;
- if (np) {
- const char *mac = of_get_mac_address(np);
- if (mac)
- iap = (unsigned char *) mac;
- }
- }
-#endif
-
- /*
- * 3) from flash or fuse (via platform data)
- */
- if (!is_valid_ether_addr(iap)) {
-#ifdef CONFIG_M5272
- if (FEC_FLASHMAC)
- iap = (unsigned char *)FEC_FLASHMAC;
-#else
- if (pdata)
- iap = (unsigned char *)&pdata->mac;
-#endif
- }
-
- /*
- * 4) FEC mac registers set by bootloader
- */
- if (!is_valid_ether_addr(iap)) {
- *((unsigned long *) &tmpaddr[0]) =
- be32_to_cpu(readl(fep->hwp + FEC_ADDR_LOW));
- *((unsigned short *) &tmpaddr[4]) =
- be16_to_cpu(readl(fep->hwp + FEC_ADDR_HIGH) >> 16);
- iap = &tmpaddr[0];
- }
-
- memcpy(ndev->dev_addr, iap, ETH_ALEN);
-
- /* Adjust MAC if using macaddr */
- if (iap == macaddr)
- ndev->dev_addr[ETH_ALEN-1] = macaddr[ETH_ALEN-1] + fep->dev_id;
-}
-
-/* ------------------------------------------------------------------------- */
-
-/*
- * Phy section
- */
-static void fec_enet_mdio_done(rtdm_nrtsig_t *nrt_sig, void* data)
-{
- struct fec_enet_private *fep = data;
-
- complete(&fep->mdio_done);
-}
-
-static void fec_enet_adjust_link(struct net_device *netdev)
-{
- struct fec_enet_netdev_priv *npriv = netdev_priv(netdev);
- struct rtnet_device *ndev = npriv->rtdev;
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- struct phy_device *phy_dev = fep->phy_dev;
- unsigned long context;
-
- int status_change = 0;
-
- rtdm_lock_get_irqsave(&fep->hw_lock, context);
-
- /* Prevent a state halted on mii error */
- if (fep->mii_timeout && phy_dev->state == PHY_HALTED) {
- phy_dev->state = PHY_RESUMING;
- goto spin_unlock;
- }
-
- /* Duplex link change */
- if (phy_dev->link) {
- if (fep->full_duplex != phy_dev->duplex) {
- fec_restart(ndev, phy_dev->duplex);
- /* prevent unnecessary second fec_restart() below */
- fep->link = phy_dev->link;
- status_change = 1;
- }
- }
-
- /* Link on or off change */
- if (phy_dev->link != fep->link) {
- fep->link = phy_dev->link;
- if (phy_dev->link)
- fec_restart(ndev, phy_dev->duplex);
- else
- fec_stop(ndev);
- status_change = 1;
- }
-
-spin_unlock:
- rtdm_lock_put_irqrestore(&fep->hw_lock, context);
-
- if (status_change)
- phy_print_status(phy_dev);
-}
-
-static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
-{
- struct fec_enet_private *fep = bus->priv;
- unsigned long time_left;
-
- fep->mii_timeout = 0;
- init_completion(&fep->mdio_done);
-
- /* start a read op */
- writel(FEC_MMFR_ST | FEC_MMFR_OP_READ |
- FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
- FEC_MMFR_TA, fep->hwp + FEC_MII_DATA);
-
- /* wait for end of transfer */
- time_left = wait_for_completion_timeout(&fep->mdio_done,
- usecs_to_jiffies(FEC_MII_TIMEOUT));
- if (time_left == 0) {
- fep->mii_timeout = 1;
- printk(KERN_ERR "FEC: MDIO read timeout\n");
- return -ETIMEDOUT;
- }
-
- /* return value */
- return FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
-}
-
-static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
- u16 value)
-{
- struct fec_enet_private *fep = bus->priv;
- unsigned long time_left;
-
- fep->mii_timeout = 0;
- init_completion(&fep->mdio_done);
-
- /* start a write op */
- writel(FEC_MMFR_ST | FEC_MMFR_OP_WRITE |
- FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
- FEC_MMFR_TA | FEC_MMFR_DATA(value),
- fep->hwp + FEC_MII_DATA);
-
- /* wait for end of transfer */
- time_left = wait_for_completion_timeout(&fep->mdio_done,
- usecs_to_jiffies(FEC_MII_TIMEOUT));
- if (time_left == 0) {
- fep->mii_timeout = 1;
- printk(KERN_ERR "FEC: MDIO write timeout\n");
- return -ETIMEDOUT;
- }
-
- return 0;
-}
-
-static int fec_enet_mdio_reset(struct mii_bus *bus)
-{
- return 0;
-}
-
-static int fec_enet_mii_probe(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- const struct platform_device_id *id_entry =
- platform_get_device_id(fep->pdev);
- struct phy_device *phy_dev = NULL;
- char mdio_bus_id[MII_BUS_ID_SIZE];
- char phy_name[MII_BUS_ID_SIZE + 3];
- int phy_id;
- int dev_id = fep->dev_id;
-
- fep->phy_dev = NULL;
-
- /* check for attached phy */
- for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
- if ((fep->mii_bus->phy_mask & (1 << phy_id)))
- continue;
- if (fep->mii_bus->phy_map[phy_id] == NULL)
- continue;
- if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
- continue;
- if (dev_id--)
- continue;
- strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
- break;
- }
-
- if (phy_id >= PHY_MAX_ADDR) {
- printk(KERN_INFO
- "%s: no PHY, assuming direct connection to switch\n",
- ndev->name);
- strncpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
- phy_id = 0;
- }
-
- snprintf(phy_name, sizeof(phy_name), PHY_ID_FMT, mdio_bus_id, phy_id);
- /* attach the mac to the phy using the dummy linux netdev */
- phy_dev = phy_connect(fep->netdev, phy_name, &fec_enet_adjust_link, 0,
- fep->phy_interface);
- if (IS_ERR(phy_dev)) {
- printk(KERN_ERR "%s: could not attach to PHY\n", ndev->name);
- return PTR_ERR(phy_dev);
- }
-
- /* mask with MAC supported features */
- if (id_entry->driver_data & FEC_QUIRK_HAS_GBIT)
- phy_dev->supported &= PHY_GBIT_FEATURES;
- else
- phy_dev->supported &= PHY_BASIC_FEATURES;
-
- phy_dev->advertising = phy_dev->supported;
-
- fep->phy_dev = phy_dev;
- fep->link = 0;
- fep->full_duplex = 0;
-
- printk(KERN_INFO
- "%s: Freescale FEC PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
- ndev->name,
- fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
- fep->phy_dev->irq);
-
- return 0;
-}
-
-static int fec_enet_mii_init(struct platform_device *pdev)
-{
- static struct mii_bus *fec0_mii_bus;
- struct rtnet_device *ndev = platform_get_drvdata(pdev);
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- const struct platform_device_id *id_entry =
- platform_get_device_id(fep->pdev);
- int err = -ENXIO, i;
-
- /*
- * The dual fec interfaces are not equivalent with enet-mac.
- * Here are the differences:
- *
- * - fec0 supports MII & RMII modes while fec1 only supports RMII
- * - fec0 acts as the 1588 time master while fec1 is slave
- * - external phys can only be configured by fec0
- *
- * That is to say fec1 can not work independently. It only works
- * when fec0 is working. The reason behind this design is that the
- * second interface is added primarily for Switch mode.
- *
- * Because of the last point above, both phys are attached on fec0
- * mdio interface in board design, and need to be configured by
- * fec0 mii_bus.
- */
- if ((id_entry->driver_data & FEC_QUIRK_ENET_MAC) && fep->dev_id > 0) {
- /* fec1 uses fec0 mii_bus */
- if (mii_cnt && fec0_mii_bus) {
- fep->mii_bus = fec0_mii_bus;
- mii_cnt++;
- return 0;
- }
- return -ENOENT;
- }
-
- fep->mii_timeout = 0;
-
- /*
- * Set MII speed to 2.5 MHz (= clk_get_rate() / 2 * phy_speed)
- *
- * The formula for FEC MDC is 'ref_freq / (MII_SPEED x 2)' while
- * for ENET-MAC is 'ref_freq / ((MII_SPEED + 1) x 2)'. The i.MX28
- * Reference Manual has an error on this, and gets fixed on i.MX6Q
- * document.
- */
- fep->phy_speed = DIV_ROUND_UP(clk_get_rate(fep->clk_ahb), 5000000);
- if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
- fep->phy_speed--;
- fep->phy_speed <<= 1;
- writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
-
- fep->mii_bus = mdiobus_alloc();
- if (fep->mii_bus == NULL) {
- err = -ENOMEM;
- goto err_out;
- }
-
- fep->mii_bus->name = "fec_enet_mii_bus";
- fep->mii_bus->read = fec_enet_mdio_read;
- fep->mii_bus->write = fec_enet_mdio_write;
- fep->mii_bus->reset = fec_enet_mdio_reset;
- snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
- pdev->name, fep->dev_id + 1);
- fep->mii_bus->priv = fep;
- fep->mii_bus->parent = &pdev->dev;
-
- fep->mii_bus->irq = kmalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
- if (!fep->mii_bus->irq) {
- err = -ENOMEM;
- goto err_out_free_mdiobus;
- }
-
- for (i = 0; i < PHY_MAX_ADDR; i++)
- fep->mii_bus->irq[i] = PHY_POLL;
-
- rtdm_nrtsig_init(&fep->mdio_done_sig, fec_enet_mdio_done, fep);
-
- if (mdiobus_register(fep->mii_bus))
- goto err_out_destroy_nrt;
-
- mii_cnt++;
-
- /* save fec0 mii_bus */
- if (id_entry->driver_data & FEC_QUIRK_ENET_MAC)
- fec0_mii_bus = fep->mii_bus;
-
- return 0;
-
-err_out_destroy_nrt:
- rtdm_nrtsig_destroy(&fep->mdio_done_sig);
- kfree(fep->mii_bus->irq);
-err_out_free_mdiobus:
- mdiobus_free(fep->mii_bus);
-err_out:
- return err;
-}
-
-static void fec_enet_mii_remove(struct fec_enet_private *fep)
-{
- if (--mii_cnt == 0) {
- mdiobus_unregister(fep->mii_bus);
- kfree(fep->mii_bus->irq);
- mdiobus_free(fep->mii_bus);
- }
- rtdm_nrtsig_destroy(&fep->mdio_done_sig);
-}
-
-static int
-fec_enet_ioctl(struct rtnet_device *ndev, unsigned int request, void *arg)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- struct phy_device *phydev = fep->phy_dev;
- struct ifreq *ifr = arg;
- struct ethtool_value *value;
- struct ethtool_cmd cmd;
- int err = 0;
-
- if (!rtnetif_running(ndev))
- return -EINVAL;
-
- if (!phydev)
- return -ENODEV;
-
- switch (request) {
- case SIOCETHTOOL:
- value = (struct ethtool_value *)ifr->ifr_data;
- switch (value->cmd) {
- case ETHTOOL_GLINK:
- value->data = fep->link;
- if (copy_to_user(&value->data, &fep->link,
- sizeof(value->data)))
- err = -EFAULT;
- break;
- case ETHTOOL_GSET:
- memset(&cmd, 0, sizeof(cmd));
- cmd.cmd = ETHTOOL_GSET;
- err = phy_ethtool_gset(phydev, &cmd);
- if (err)
- break;
- if (copy_to_user(ifr->ifr_data, &cmd, sizeof(cmd)))
- err = -EFAULT;
- break;
- case ETHTOOL_SSET:
- if (copy_from_user(&cmd, ifr->ifr_data, sizeof(cmd)))
- err = -EFAULT;
- else
- err = phy_ethtool_sset(phydev, &cmd);
- break;
- }
- break;
- default:
- err = -EOPNOTSUPP;
- break;
- }
-
- return err;
-}
-
-static void fec_enet_free_buffers(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- int i;
- struct rtskb *skb;
- struct bufdesc *bdp;
-
- bdp = fep->rx_bd_base;
- for (i = 0; i < RX_RING_SIZE; i++) {
- skb = fep->rx_skbuff[i];
-
- if (bdp->cbd_bufaddr)
- dma_unmap_single(&fep->pdev->dev, bdp->cbd_bufaddr,
- FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
- if (skb)
- dev_kfree_rtskb(skb); /* RTnet */
- bdp++;
- }
-
- bdp = fep->tx_bd_base;
- for (i = 0; i < TX_RING_SIZE; i++)
- kfree(fep->tx_bounce[i]);
-}
-
-static int fec_enet_alloc_buffers(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- int i;
- struct rtskb *skb;
- struct bufdesc *bdp;
-
- bdp = fep->rx_bd_base;
- for (i = 0; i < RX_RING_SIZE; i++) {
- skb = rtnetdev_alloc_rtskb(netdev, FEC_ENET_RX_FRSIZE); /* RTnet */
- if (!skb) {
- fec_enet_free_buffers(ndev);
- return -ENOMEM;
- }
- fep->rx_skbuff[i] = skb;
-
- bdp->cbd_bufaddr = dma_map_single(&fep->pdev->dev, skb->data,
- FEC_ENET_RX_FRSIZE, DMA_FROM_DEVICE);
- bdp->cbd_sc = BD_ENET_RX_EMPTY;
- bdp++;
- }
-
- /* Set the last buffer to wrap. */
- bdp--;
- bdp->cbd_sc |= BD_SC_WRAP;
-
- bdp = fep->tx_bd_base;
- for (i = 0; i < TX_RING_SIZE; i++) {
- fep->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);
-
- bdp->cbd_sc = 0;
- bdp->cbd_bufaddr = 0;
- bdp++;
- }
-
- /* Set the last buffer to wrap. */
- bdp--;
- bdp->cbd_sc |= BD_SC_WRAP;
-
- return 0;
-}
-
-static int
-fec_enet_open(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- int ret;
-
- /* I should reset the ring buffers here, but I don't yet know
- * a simple way to do that.
- */
-
- ret = fec_enet_alloc_buffers(ndev);
- if (ret)
- return ret;
-
- /* RTnet */
- rt_stack_connect(ndev, &STACK_manager);
-
- /* Probe and connect to PHY when open the interface */
- ret = fec_enet_mii_probe(ndev);
- if (ret) {
- fec_enet_free_buffers(ndev);
- return ret;
- }
- phy_start(fep->phy_dev);
- rtnetif_carrier_on(ndev);
- rtnetif_start_queue(ndev);
- fep->opened = 1;
- return 0;
-}
-
-static int
-fec_enet_close(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
-
- /* Don't know what to do yet. */
- fep->opened = 0;
- rtnetif_stop_queue(ndev);
- fec_stop(ndev);
-
- if (fep->phy_dev) {
- phy_stop(fep->phy_dev);
- phy_disconnect(fep->phy_dev);
- }
-
- fec_enet_free_buffers(ndev);
-
- /* RTnet */
- rt_stack_disconnect(ndev);
-
- return 0;
-}
-
-#ifdef CONFIG_XENO_DRIVERS_NET_MULTICAST
-/* Set or clear the multicast filter for this adaptor.
- * Skeleton taken from sunlance driver.
- * The CPM Ethernet implementation allows Multicast as well as individual
- * MAC address filtering. Some of the drivers check to make sure it is
- * a group multicast address, and discard those that are not. I guess I
- * will do the same for now, but just remove the test if you want
- * individual filtering as well (do the upper net layers want or support
- * this kind of feature?).
- */
-
-#define HASH_BITS 6 /* #bits in hash */
-#define CRC32_POLY 0xEDB88320
-
-static void set_multicast_list(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- struct netdev_hw_addr *ha;
- unsigned int i, bit, data, crc, tmp;
- unsigned char hash;
-
- if (ndev->flags & IFF_PROMISC) {
- tmp = readl(fep->hwp + FEC_R_CNTRL);
- tmp |= 0x8;
- writel(tmp, fep->hwp + FEC_R_CNTRL);
- return;
- }
-
- tmp = readl(fep->hwp + FEC_R_CNTRL);
- tmp &= ~0x8;
- writel(tmp, fep->hwp + FEC_R_CNTRL);
-
- if (ndev->flags & IFF_ALLMULTI) {
- /* Catch all multicast addresses, so set the
- * filter to all 1's
- */
- writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
- writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
-
- return;
- }
-
- /* Clear filter and add the addresses in hash register
- */
- writel(0, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
- writel(0, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
-
- rtnetdev_for_each_mc_addr(ha, ndev) {
- /* calculate crc32 value of mac address */
- crc = 0xffffffff;
-
- for (i = 0; i < ndev->addr_len; i++) {
- data = ha->addr[i];
- for (bit = 0; bit < 8; bit++, data >>= 1) {
- crc = (crc >> 1) ^
- (((crc ^ data) & 1) ? CRC32_POLY : 0);
- }
- }
-
- /* only upper 6 bits (HASH_BITS) are used
- * which point to specific bit in he hash registers
- */
- hash = (crc >> (32 - HASH_BITS)) & 0x3f;
-
- if (hash > 31) {
- tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
- tmp |= 1 << (hash - 32);
- writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
- } else {
- tmp = readl(fep->hwp + FEC_GRP_HASH_TABLE_LOW);
- tmp |= 1 << hash;
- writel(tmp, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
- }
- }
-}
-#endif /* CONFIG_XENO_DRIVERS_NET_MULTICAST */
-
-#ifdef ORIGINAL_CODE
-/* Set a MAC change in hardware. */
-static int
-fec_set_mac_address(struct rtnet_device *ndev, void *p)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- struct sockaddr *addr = p;
-
- if (!is_valid_ether_addr(addr->sa_data))
- return -EADDRNOTAVAIL;
-
- memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
-
- writel(ndev->dev_addr[3] | (ndev->dev_addr[2] << 8) |
- (ndev->dev_addr[1] << 16) | (ndev->dev_addr[0] << 24),
- fep->hwp + FEC_ADDR_LOW);
- writel((ndev->dev_addr[5] << 16) | (ndev->dev_addr[4] << 24),
- fep->hwp + FEC_ADDR_HIGH);
- return 0;
-}
-
-#ifdef CONFIG_NET_POLL_CONTROLLER
-/*
- * fec_poll_controller: FEC Poll controller function
- * @dev: The FEC network adapter
- *
- * Polled functionality used by netconsole and others in non interrupt mode
- *
- */
-void fec_poll_controller(struct rtnet_device *dev)
-{
- int i;
- struct fec_enet_private *fep = rtnetdev_priv(dev);
-
- for (i = 0; i < FEC_IRQ_NUM; i++) {
- if (fep->irq[i] > 0) {
- disable_irq(fep->irq[i]);
- fec_enet_interrupt(fep->irq[i], dev);
- enable_irq(fep->irq[i]);
- }
- }
-}
-#endif /* ORIGINAL_CODE */
-
-static const struct rtnet_device_ops fec_netdev_ops = {
- .ndo_open = fec_enet_open,
- .ndo_stop = fec_enet_close,
- .ndo_start_xmit = fec_enet_start_xmit,
- .ndo_set_rx_mode = set_multicast_list,
- .ndo_change_mtu = eth_change_mtu,
- .ndo_validate_addr = eth_validate_addr,
- .ndo_tx_timeout = fec_timeout,
- .ndo_set_mac_address = fec_set_mac_address,
-#ifdef CONFIG_NET_POLL_CONTROLLER
- .ndo_poll_controller = fec_poll_controller,
-#endif
-};
-#endif
-
-/* RTnet: get statistics */
-static struct net_device_stats *fec_get_stats(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- return &fep->stats;
-}
-
- /*
- * XXX: We need to clean up on failure exits here.
- *
- */
-static int fec_enet_init(struct rtnet_device *ndev)
-{
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- struct bufdesc *cbd_base;
- struct bufdesc *bdp;
- int i;
-
- /* Allocate memory for buffer descriptors. */
- cbd_base = dma_alloc_coherent(NULL, PAGE_SIZE, &fep->bd_dma,
- GFP_KERNEL);
- if (!cbd_base) {
- printk("FEC: allocate descriptor memory failed?\n");
- return -ENOMEM;
- }
-
- rtdm_lock_init(&fep->hw_lock);
-
- /* Get the Ethernet address */
- fec_get_mac(ndev);
-
- /* Set receive and transmit descriptor base. */
- fep->rx_bd_base = cbd_base;
- fep->tx_bd_base = cbd_base + RX_RING_SIZE;
-
- /* RTnet: specific entries in the device structure */
- ndev->open = fec_enet_open;
- ndev->stop = fec_enet_close;
- ndev->hard_start_xmit = fec_enet_start_xmit;
- ndev->get_stats = fec_get_stats;
- ndev->do_ioctl = fec_enet_ioctl;
-#ifdef CONFIG_XENO_DRIVERS_NET_MULTICAST
- ndev->set_multicast_list = &set_multicast_list;
-#endif
-
- /* Initialize the receive buffer descriptors. */
- bdp = fep->rx_bd_base;
- for (i = 0; i < RX_RING_SIZE; i++) {
-
- /* Initialize the BD for every fragment in the page. */
- bdp->cbd_sc = 0;
- bdp++;
- }
-
- /* Set the last buffer to wrap */
- bdp--;
- bdp->cbd_sc |= BD_SC_WRAP;
-
- /* ...and the same for transmit */
- bdp = fep->tx_bd_base;
- for (i = 0; i < TX_RING_SIZE; i++) {
-
- /* Initialize the BD for every fragment in the page. */
- bdp->cbd_sc = 0;
- bdp->cbd_bufaddr = 0;
- bdp++;
- }
-
- /* Set the last buffer to wrap */
- bdp--;
- bdp->cbd_sc |= BD_SC_WRAP;
-
- fec_restart(ndev, 0);
-
- return 0;
-}
-
-#ifdef CONFIG_OF
-static int fec_get_phy_mode_dt(struct platform_device *pdev)
-{
- struct device_node *np = pdev->dev.of_node;
-
- if (np)
- return of_get_phy_mode(np);
-
- return -ENODEV;
-}
-
-static void fec_reset_phy(struct platform_device *pdev)
-{
- int err, phy_reset;
- struct device_node *np = pdev->dev.of_node;
-
- if (!np)
- return;
-
- phy_reset = of_get_named_gpio(np, "phy-reset-gpios", 0);
- err = gpio_request_one(phy_reset, GPIOF_OUT_INIT_LOW, "phy-reset");
- if (err) {
- pr_debug("FEC: failed to get gpio phy-reset: %d\n", err);
- return;
- }
- msleep(1);
- gpio_set_value(phy_reset, 1);
-}
-#else /* CONFIG_OF */
-static inline int fec_get_phy_mode_dt(struct platform_device *pdev)
-{
- return -ENODEV;
-}
-
-static inline void fec_reset_phy(struct platform_device *pdev)
-{
- /*
- * In case of platform probe, the reset has been done
- * by machine code.
- */
-}
-#endif /* CONFIG_OF */
-
-static int fec_probe(struct platform_device *pdev)
-{
- struct fec_enet_netdev_priv *npriv;
- struct fec_enet_private *fep;
- struct fec_platform_data *pdata;
- struct rtnet_device *ndev;
- int i, irq, ret = 0;
- struct resource *r;
- const struct of_device_id *of_id;
- static int dev_id;
- struct pinctrl *pinctrl;
-
- of_id = of_match_device(fec_dt_ids, &pdev->dev);
- if (of_id)
- pdev->id_entry = of_id->data;
-
- r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- if (!r)
- return -ENXIO;
-
- r = request_mem_region(r->start, resource_size(r), pdev->name);
- if (!r)
- return -EBUSY;
-
- /* Init network device */
- ndev = rt_alloc_etherdev(sizeof(struct fec_enet_private),
- rx_pool_size + TX_RING_SIZE);
- if (!ndev) {
- ret = -ENOMEM;
- goto failed_alloc_etherdev;
- }
-
- /* RTnet */
- rtdev_alloc_name(ndev, "rteth%d");
- rt_rtdev_connect(ndev, &RTDEV_manager);
- ndev->vers = RTDEV_VERS_2_0;
- ndev->sysbind = &pdev->dev;
-
- /* setup board info structure */
- fep = rtnetdev_priv(ndev);
- memset(fep, 0, sizeof(*fep));
-
- /* RTnet: allocate dummy linux netdev structure for phy handling */
- fep->netdev = alloc_etherdev(sizeof(struct fec_enet_netdev_priv));
- if (!fep->netdev)
- goto failed_alloc_netdev;
- SET_NETDEV_DEV(fep->netdev, &pdev->dev);
- npriv = netdev_priv(fep->netdev);
- npriv->rtdev = ndev;
-
- fep->hwp = ioremap(r->start, resource_size(r));
- fep->pdev = pdev;
- fep->dev_id = dev_id++;
-
- if (!fep->hwp) {
- ret = -ENOMEM;
- goto failed_ioremap;
- }
-
- platform_set_drvdata(pdev, ndev);
-
- ret = fec_get_phy_mode_dt(pdev);
- if (ret < 0) {
- pdata = pdev->dev.platform_data;
- if (pdata)
- fep->phy_interface = pdata->phy;
- else
- fep->phy_interface = PHY_INTERFACE_MODE_MII;
- } else {
- fep->phy_interface = ret;
- }
-
- fec_reset_phy(pdev);
-
- for (i = 0; i < FEC_IRQ_NUM; i++) {
- irq = platform_get_irq(pdev, i);
- if (irq < 0) {
- if (i)
- break;
- ret = irq;
- goto failed_irq;
- }
- ret = rtdm_irq_request(&fep->irq_handle[i], irq,
- fec_enet_interrupt, 0, ndev->name, ndev);
- if (ret) {
- while (--i >= 0) {
- irq = platform_get_irq(pdev, i);
- rtdm_irq_free(&fep->irq_handle[i]);
- }
- goto failed_irq;
- }
- }
-
- pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
- if (IS_ERR(pinctrl)) {
- ret = PTR_ERR(pinctrl);
- goto failed_pin;
- }
-
- fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
- if (IS_ERR(fep->clk_ipg)) {
- ret = PTR_ERR(fep->clk_ipg);
- goto failed_clk;
- }
-
- fep->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
- if (IS_ERR(fep->clk_ahb)) {
- ret = PTR_ERR(fep->clk_ahb);
- goto failed_clk;
- }
-
- clk_prepare_enable(fep->clk_ahb);
- clk_prepare_enable(fep->clk_ipg);
-
- ret = fec_enet_init(ndev);
- if (ret)
- goto failed_init;
-
- ret = fec_enet_mii_init(pdev);
- if (ret)
- goto failed_mii_init;
-
- /* Carrier starts down, phylib will bring it up */
- rtnetif_carrier_off(ndev);
-
- /* RTnet: register the network interface */
- ret = rt_register_rtnetdev(ndev);
- if (ret)
- goto failed_register;
-
- return 0;
-
-failed_register:
- fec_enet_mii_remove(fep);
-failed_mii_init:
-failed_init:
- clk_disable_unprepare(fep->clk_ahb);
- clk_disable_unprepare(fep->clk_ipg);
-failed_pin:
-failed_clk:
- for (i = 0; i < FEC_IRQ_NUM; i++) {
- irq = platform_get_irq(pdev, i);
- if (irq > 0)
- rtdm_irq_free(&fep->irq_handle[i]);
- }
-failed_irq:
- iounmap(fep->hwp);
-failed_ioremap:
- free_netdev(fep->netdev);
-failed_alloc_netdev:
- rtdev_free(ndev); /* RTnet */
-failed_alloc_etherdev:
- release_mem_region(r->start, resource_size(r));
-
- return ret;
-}
-
-static int fec_drv_remove(struct platform_device *pdev)
-{
- struct rtnet_device *ndev = platform_get_drvdata(pdev);
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
- struct resource *r;
- int i;
-
- /* RTnet */
- rt_unregister_rtnetdev(ndev);
- rt_rtdev_disconnect(ndev);
-
- fec_enet_mii_remove(fep);
- for (i = 0; i < FEC_IRQ_NUM; i++) {
- int irq = platform_get_irq(pdev, i);
- if (irq > 0)
- rtdm_irq_free(&fep->irq_handle[i]);
- }
-
- clk_disable_unprepare(fep->clk_ahb);
- clk_disable_unprepare(fep->clk_ipg);
- iounmap(fep->hwp);
-
- /* RTnet */
- free_netdev(fep->netdev);
- rtdev_free(ndev);
-
- r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- BUG_ON(!r);
- release_mem_region(r->start, resource_size(r));
-
- platform_set_drvdata(pdev, NULL);
-
- return 0;
-}
-
-#ifdef CONFIG_PM
-static int
-fec_suspend(struct device *dev)
-{
- struct rtnet_device *ndev = dev_get_drvdata(dev);
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
-
- if (rtnetif_running(ndev)) {
- fec_stop(ndev);
- rtnetif_device_detach(ndev);
- }
- clk_disable_unprepare(fep->clk_ahb);
- clk_disable_unprepare(fep->clk_ipg);
- return 0;
-}
-
-static int
-fec_resume(struct device *dev)
-{
- struct rtnet_device *ndev = dev_get_drvdata(dev);
- struct fec_enet_private *fep = rtnetdev_priv(ndev);
-
- clk_prepare_enable(fep->clk_ahb);
- clk_prepare_enable(fep->clk_ipg);
- if (rtnetif_running(ndev)) {
- fec_restart(ndev, fep->full_duplex);
- rtnetif_device_attach(ndev);
- }
-
- return 0;
-}
-
-static const struct dev_pm_ops fec_pm_ops = {
- .suspend = fec_suspend,
- .resume = fec_resume,
- .freeze = fec_suspend,
- .thaw = fec_resume,
- .poweroff = fec_suspend,
- .restore = fec_resume,
-};
-#endif
-
-static struct platform_driver fec_driver = {
- .driver = {
- .name = DRIVER_NAME,
- .owner = THIS_MODULE,
-#ifdef CONFIG_PM
- .pm = &fec_pm_ops,
-#endif
- .of_match_table = fec_dt_ids,
- },
- .id_table = fec_devtype,
- .probe = fec_probe,
- .remove = fec_drv_remove,
-};
-
-module_platform_driver(fec_driver);
diff --git a/kernel/drivers/net/drivers/freescale/Makefile b/kernel/drivers/net/drivers/freescale/Makefile
new file mode 100644
index 000000000..fadab2e43
--- /dev/null
+++ b/kernel/drivers/net/drivers/freescale/Makefile
@@ -0,0 +1,5 @@
+ccflags-y += -Idrivers/xenomai/net/stack/include
+
+obj-$(CONFIG_XENO_DRIVERS_NET_FEC) += rtnet_fec.o
+
+rtnet_fec-y := fec_main.o fec_ptp.o
diff --git a/kernel/drivers/net/drivers/freescale/fec.h b/kernel/drivers/net/drivers/freescale/fec.h
new file mode 100644
index 000000000..185aa6463
--- /dev/null
+++ b/kernel/drivers/net/drivers/freescale/fec.h
@@ -0,0 +1,610 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/****************************************************************************/
+
+/*
+ * fec.h -- Fast Ethernet Controller for Motorola ColdFire SoC
+ * processors.
+ *
+ * (C) Copyright 2000-2005, Greg Ungerer (gerg@snapgear.com)
+ * (C) Copyright 2000-2001, Lineo (www.lineo.com)
+ */
+
+/****************************************************************************/
+#ifndef FEC_H
+#define FEC_H
+/****************************************************************************/
+
+#include <linux/clocksource.h>
+#include <linux/net_tstamp.h>
+#include <linux/ptp_clock_kernel.h>
+#include <linux/timecounter.h>
+#include <rtnet_port.h>
+
+#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
+ defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
+/*
+ * Just figures, Motorola would have to change the offsets for
+ * registers in the same peripheral device on different models
+ * of the ColdFire!
+ */
+#define FEC_IEVENT 0x004 /* Interrupt event reg */
+#define FEC_IMASK 0x008 /* Interrupt mask reg */
+#define FEC_R_DES_ACTIVE_0 0x010 /* Receive descriptor reg */
+#define FEC_X_DES_ACTIVE_0 0x014 /* Transmit descriptor reg */
+#define FEC_ECNTRL 0x024 /* Ethernet control reg */
+#define FEC_MII_DATA 0x040 /* MII manage frame reg */
+#define FEC_MII_SPEED 0x044 /* MII speed control reg */
+#define FEC_MIB_CTRLSTAT 0x064 /* MIB control/status reg */
+#define FEC_R_CNTRL 0x084 /* Receive control reg */
+#define FEC_X_CNTRL 0x0c4 /* Transmit Control reg */
+#define FEC_ADDR_LOW 0x0e4 /* Low 32bits MAC address */
+#define FEC_ADDR_HIGH 0x0e8 /* High 16bits MAC address */
+#define FEC_OPD 0x0ec /* Opcode + Pause duration */
+#define FEC_TXIC0 0x0f0 /* Tx Interrupt Coalescing for ring 0 */
+#define FEC_TXIC1 0x0f4 /* Tx Interrupt Coalescing for ring 1 */
+#define FEC_TXIC2 0x0f8 /* Tx Interrupt Coalescing for ring 2 */
+#define FEC_RXIC0 0x100 /* Rx Interrupt Coalescing for ring 0 */
+#define FEC_RXIC1 0x104 /* Rx Interrupt Coalescing for ring 1 */
+#define FEC_RXIC2 0x108 /* Rx Interrupt Coalescing for ring 2 */
+#define FEC_HASH_TABLE_HIGH 0x118 /* High 32bits hash table */
+#define FEC_HASH_TABLE_LOW 0x11c /* Low 32bits hash table */
+#define FEC_GRP_HASH_TABLE_HIGH 0x120 /* High 32bits hash table */
+#define FEC_GRP_HASH_TABLE_LOW 0x124 /* Low 32bits hash table */
+#define FEC_X_WMRK 0x144 /* FIFO transmit water mark */
+#define FEC_R_BOUND 0x14c /* FIFO receive bound reg */
+#define FEC_R_FSTART 0x150 /* FIFO receive start reg */
+#define FEC_R_DES_START_1 0x160 /* Receive descriptor ring 1 */
+#define FEC_X_DES_START_1 0x164 /* Transmit descriptor ring 1 */
+#define FEC_R_BUFF_SIZE_1 0x168 /* Maximum receive buff ring1 size */
+#define FEC_R_DES_START_2 0x16c /* Receive descriptor ring 2 */
+#define FEC_X_DES_START_2 0x170 /* Transmit descriptor ring 2 */
+#define FEC_R_BUFF_SIZE_2 0x174 /* Maximum receive buff ring2 size */
+#define FEC_R_DES_START_0 0x180 /* Receive descriptor ring */
+#define FEC_X_DES_START_0 0x184 /* Transmit descriptor ring */
+#define FEC_R_BUFF_SIZE_0 0x188 /* Maximum receive buff size */
+#define FEC_R_FIFO_RSFL 0x190 /* Receive FIFO section full threshold */
+#define FEC_R_FIFO_RSEM 0x194 /* Receive FIFO section empty threshold */
+#define FEC_R_FIFO_RAEM 0x198 /* Receive FIFO almost empty threshold */
+#define FEC_R_FIFO_RAFL 0x19c /* Receive FIFO almost full threshold */
+#define FEC_FTRL 0x1b0 /* Frame truncation receive length*/
+#define FEC_RACC 0x1c4 /* Receive Accelerator function */
+#define FEC_RCMR_1 0x1c8 /* Receive classification match ring 1 */
+#define FEC_RCMR_2 0x1cc /* Receive classification match ring 2 */
+#define FEC_DMA_CFG_1 0x1d8 /* DMA class configuration for ring 1 */
+#define FEC_DMA_CFG_2 0x1dc /* DMA class Configuration for ring 2 */
+#define FEC_R_DES_ACTIVE_1 0x1e0 /* Rx descriptor active for ring 1 */
+#define FEC_X_DES_ACTIVE_1 0x1e4 /* Tx descriptor active for ring 1 */
+#define FEC_R_DES_ACTIVE_2 0x1e8 /* Rx descriptor active for ring 2 */
+#define FEC_X_DES_ACTIVE_2 0x1ec /* Tx descriptor active for ring 2 */
+#define FEC_QOS_SCHEME 0x1f0 /* Set multi queues Qos scheme */
+#define FEC_MIIGSK_CFGR 0x300 /* MIIGSK Configuration reg */
+#define FEC_MIIGSK_ENR 0x308 /* MIIGSK Enable reg */
+
+#define BM_MIIGSK_CFGR_MII 0x00
+#define BM_MIIGSK_CFGR_RMII 0x01
+#define BM_MIIGSK_CFGR_FRCONT_10M 0x40
+
+#define RMON_T_DROP 0x200 /* Count of frames not cntd correctly */
+#define RMON_T_PACKETS 0x204 /* RMON TX packet count */
+#define RMON_T_BC_PKT 0x208 /* RMON TX broadcast pkts */
+#define RMON_T_MC_PKT 0x20c /* RMON TX multicast pkts */
+#define RMON_T_CRC_ALIGN 0x210 /* RMON TX pkts with CRC align err */
+#define RMON_T_UNDERSIZE 0x214 /* RMON TX pkts < 64 bytes, good CRC */
+#define RMON_T_OVERSIZE 0x218 /* RMON TX pkts > MAX_FL bytes good CRC */
+#define RMON_T_FRAG 0x21c /* RMON TX pkts < 64 bytes, bad CRC */
+#define RMON_T_JAB 0x220 /* RMON TX pkts > MAX_FL bytes, bad CRC */
+#define RMON_T_COL 0x224 /* RMON TX collision count */
+#define RMON_T_P64 0x228 /* RMON TX 64 byte pkts */
+#define RMON_T_P65TO127 0x22c /* RMON TX 65 to 127 byte pkts */
+#define RMON_T_P128TO255 0x230 /* RMON TX 128 to 255 byte pkts */
+#define RMON_T_P256TO511 0x234 /* RMON TX 256 to 511 byte pkts */
+#define RMON_T_P512TO1023 0x238 /* RMON TX 512 to 1023 byte pkts */
+#define RMON_T_P1024TO2047 0x23c /* RMON TX 1024 to 2047 byte pkts */
+#define RMON_T_P_GTE2048 0x240 /* RMON TX pkts > 2048 bytes */
+#define RMON_T_OCTETS 0x244 /* RMON TX octets */
+#define IEEE_T_DROP 0x248 /* Count of frames not counted crtly */
+#define IEEE_T_FRAME_OK 0x24c /* Frames tx'd OK */
+#define IEEE_T_1COL 0x250 /* Frames tx'd with single collision */
+#define IEEE_T_MCOL 0x254 /* Frames tx'd with multiple collision */
+#define IEEE_T_DEF 0x258 /* Frames tx'd after deferral delay */
+#define IEEE_T_LCOL 0x25c /* Frames tx'd with late collision */
+#define IEEE_T_EXCOL 0x260 /* Frames tx'd with excesv collisions */
+#define IEEE_T_MACERR 0x264 /* Frames tx'd with TX FIFO underrun */
+#define IEEE_T_CSERR 0x268 /* Frames tx'd with carrier sense err */
+#define IEEE_T_SQE 0x26c /* Frames tx'd with SQE err */
+#define IEEE_T_FDXFC 0x270 /* Flow control pause frames tx'd */
+#define IEEE_T_OCTETS_OK 0x274 /* Octet count for frames tx'd w/o err */
+#define RMON_R_PACKETS 0x284 /* RMON RX packet count */
+#define RMON_R_BC_PKT 0x288 /* RMON RX broadcast pkts */
+#define RMON_R_MC_PKT 0x28c /* RMON RX multicast pkts */
+#define RMON_R_CRC_ALIGN 0x290 /* RMON RX pkts with CRC alignment err */
+#define RMON_R_UNDERSIZE 0x294 /* RMON RX pkts < 64 bytes, good CRC */
+#define RMON_R_OVERSIZE 0x298 /* RMON RX pkts > MAX_FL bytes good CRC */
+#define RMON_R_FRAG 0x29c /* RMON RX pkts < 64 bytes, bad CRC */
+#define RMON_R_JAB 0x2a0 /* RMON RX pkts > MAX_FL bytes, bad CRC */
+#define RMON_R_RESVD_O 0x2a4 /* Reserved */
+#define RMON_R_P64 0x2a8 /* RMON RX 64 byte pkts */
+#define RMON_R_P65TO127 0x2ac /* RMON RX 65 to 127 byte pkts */
+#define RMON_R_P128TO255 0x2b0 /* RMON RX 128 to 255 byte pkts */
+#define RMON_R_P256TO511 0x2b4 /* RMON RX 256 to 511 byte pkts */
+#define RMON_R_P512TO1023 0x2b8 /* RMON RX 512 to 1023 byte pkts */
+#define RMON_R_P1024TO2047 0x2bc /* RMON RX 1024 to 2047 byte pkts */
+#define RMON_R_P_GTE2048 0x2c0 /* RMON RX pkts > 2048 bytes */
+#define RMON_R_OCTETS 0x2c4 /* RMON RX octets */
+#define IEEE_R_DROP 0x2c8 /* Count frames not counted correctly */
+#define IEEE_R_FRAME_OK 0x2cc /* Frames rx'd OK */
+#define IEEE_R_CRC 0x2d0 /* Frames rx'd with CRC err */
+#define IEEE_R_ALIGN 0x2d4 /* Frames rx'd with alignment err */
+#define IEEE_R_MACERR 0x2d8 /* Receive FIFO overflow count */
+#define IEEE_R_FDXFC 0x2dc /* Flow control pause frames rx'd */
+#define IEEE_R_OCTETS_OK 0x2e0 /* Octet cnt for frames rx'd w/o err */
+
+#else
+
+#define FEC_ECNTRL 0x000 /* Ethernet control reg */
+#define FEC_IEVENT 0x004 /* Interrupt even reg */
+#define FEC_IMASK 0x008 /* Interrupt mask reg */
+#define FEC_IVEC 0x00c /* Interrupt vec status reg */
+#define FEC_R_DES_ACTIVE_0 0x010 /* Receive descriptor reg */
+#define FEC_R_DES_ACTIVE_1 FEC_R_DES_ACTIVE_0
+#define FEC_R_DES_ACTIVE_2 FEC_R_DES_ACTIVE_0
+#define FEC_X_DES_ACTIVE_0 0x014 /* Transmit descriptor reg */
+#define FEC_X_DES_ACTIVE_1 FEC_X_DES_ACTIVE_0
+#define FEC_X_DES_ACTIVE_2 FEC_X_DES_ACTIVE_0
+#define FEC_MII_DATA 0x040 /* MII manage frame reg */
+#define FEC_MII_SPEED 0x044 /* MII speed control reg */
+#define FEC_R_BOUND 0x08c /* FIFO receive bound reg */
+#define FEC_R_FSTART 0x090 /* FIFO receive start reg */
+#define FEC_X_WMRK 0x0a4 /* FIFO transmit water mark */
+#define FEC_X_FSTART 0x0ac /* FIFO transmit start reg */
+#define FEC_R_CNTRL 0x104 /* Receive control reg */
+#define FEC_MAX_FRM_LEN 0x108 /* Maximum frame length reg */
+#define FEC_X_CNTRL 0x144 /* Transmit Control reg */
+#define FEC_ADDR_LOW 0x3c0 /* Low 32bits MAC address */
+#define FEC_ADDR_HIGH 0x3c4 /* High 16bits MAC address */
+#define FEC_GRP_HASH_TABLE_HIGH 0x3c8 /* High 32bits hash table */
+#define FEC_GRP_HASH_TABLE_LOW 0x3cc /* Low 32bits hash table */
+#define FEC_R_DES_START_0 0x3d0 /* Receive descriptor ring */
+#define FEC_R_DES_START_1 FEC_R_DES_START_0
+#define FEC_R_DES_START_2 FEC_R_DES_START_0
+#define FEC_X_DES_START_0 0x3d4 /* Transmit descriptor ring */
+#define FEC_X_DES_START_1 FEC_X_DES_START_0
+#define FEC_X_DES_START_2 FEC_X_DES_START_0
+#define FEC_R_BUFF_SIZE_0 0x3d8 /* Maximum receive buff size */
+#define FEC_R_BUFF_SIZE_1 FEC_R_BUFF_SIZE_0
+#define FEC_R_BUFF_SIZE_2 FEC_R_BUFF_SIZE_0
+#define FEC_FIFO_RAM 0x400 /* FIFO RAM buffer */
+/* Not existed in real chip
+ * Just for pass build.
+ */
+#define FEC_RCMR_1 0xfff
+#define FEC_RCMR_2 0xfff
+#define FEC_DMA_CFG_1 0xfff
+#define FEC_DMA_CFG_2 0xfff
+#define FEC_TXIC0 0xfff
+#define FEC_TXIC1 0xfff
+#define FEC_TXIC2 0xfff
+#define FEC_RXIC0 0xfff
+#define FEC_RXIC1 0xfff
+#define FEC_RXIC2 0xfff
+#endif /* CONFIG_M5272 */
+
+
+/*
+ * Define the buffer descriptor structure.
+ *
+ * Evidently, ARM SoCs have the FEC block generated in a
+ * little endian mode so adjust endianness accordingly.
+ */
+#if defined(CONFIG_ARM)
+#define fec32_to_cpu le32_to_cpu
+#define fec16_to_cpu le16_to_cpu
+#define cpu_to_fec32 cpu_to_le32
+#define cpu_to_fec16 cpu_to_le16
+#define __fec32 __le32
+#define __fec16 __le16
+
+struct bufdesc {
+ __fec16 cbd_datlen; /* Data length */
+ __fec16 cbd_sc; /* Control and status info */
+ __fec32 cbd_bufaddr; /* Buffer address */
+};
+#else
+#define fec32_to_cpu be32_to_cpu
+#define fec16_to_cpu be16_to_cpu
+#define cpu_to_fec32 cpu_to_be32
+#define cpu_to_fec16 cpu_to_be16
+#define __fec32 __be32
+#define __fec16 __be16
+
+struct bufdesc {
+ __fec16 cbd_sc; /* Control and status info */
+ __fec16 cbd_datlen; /* Data length */
+ __fec32 cbd_bufaddr; /* Buffer address */
+};
+#endif
+
+struct bufdesc_ex {
+ struct bufdesc desc;
+ __fec32 cbd_esc;
+ __fec32 cbd_prot;
+ __fec32 cbd_bdu;
+ __fec32 ts;
+ __fec16 res0[4];
+};
+
+/*
+ * The following definitions courtesy of commproc.h, which where
+ * Copyright (c) 1997 Dan Malek (dmalek@jlc.net).
+ */
+#define BD_SC_EMPTY ((ushort)0x8000) /* Receive is empty */
+#define BD_SC_READY ((ushort)0x8000) /* Transmit is ready */
+#define BD_SC_WRAP ((ushort)0x2000) /* Last buffer descriptor */
+#define BD_SC_INTRPT ((ushort)0x1000) /* Interrupt on change */
+#define BD_SC_CM ((ushort)0x0200) /* Continuous mode */
+#define BD_SC_ID ((ushort)0x0100) /* Rec'd too many idles */
+#define BD_SC_P ((ushort)0x0100) /* xmt preamble */
+#define BD_SC_BR ((ushort)0x0020) /* Break received */
+#define BD_SC_FR ((ushort)0x0010) /* Framing error */
+#define BD_SC_PR ((ushort)0x0008) /* Parity error */
+#define BD_SC_OV ((ushort)0x0002) /* Overrun */
+#define BD_SC_CD ((ushort)0x0001) /* ?? */
+
+/* Buffer descriptor control/status used by Ethernet receive.
+ */
+#define BD_ENET_RX_EMPTY ((ushort)0x8000)
+#define BD_ENET_RX_WRAP ((ushort)0x2000)
+#define BD_ENET_RX_INTR ((ushort)0x1000)
+#define BD_ENET_RX_LAST ((ushort)0x0800)
+#define BD_ENET_RX_FIRST ((ushort)0x0400)
+#define BD_ENET_RX_MISS ((ushort)0x0100)
+#define BD_ENET_RX_LG ((ushort)0x0020)
+#define BD_ENET_RX_NO ((ushort)0x0010)
+#define BD_ENET_RX_SH ((ushort)0x0008)
+#define BD_ENET_RX_CR ((ushort)0x0004)
+#define BD_ENET_RX_OV ((ushort)0x0002)
+#define BD_ENET_RX_CL ((ushort)0x0001)
+#define BD_ENET_RX_STATS ((ushort)0x013f) /* All status bits */
+
+/* Enhanced buffer descriptor control/status used by Ethernet receive */
+#define BD_ENET_RX_VLAN 0x00000004
+
+/* Buffer descriptor control/status used by Ethernet transmit.
+ */
+#define BD_ENET_TX_READY ((ushort)0x8000)
+#define BD_ENET_TX_PAD ((ushort)0x4000)
+#define BD_ENET_TX_WRAP ((ushort)0x2000)
+#define BD_ENET_TX_INTR ((ushort)0x1000)
+#define BD_ENET_TX_LAST ((ushort)0x0800)
+#define BD_ENET_TX_TC ((ushort)0x0400)
+#define BD_ENET_TX_DEF ((ushort)0x0200)
+#define BD_ENET_TX_HB ((ushort)0x0100)
+#define BD_ENET_TX_LC ((ushort)0x0080)
+#define BD_ENET_TX_RL ((ushort)0x0040)
+#define BD_ENET_TX_RCMASK ((ushort)0x003c)
+#define BD_ENET_TX_UN ((ushort)0x0002)
+#define BD_ENET_TX_CSL ((ushort)0x0001)
+#define BD_ENET_TX_STATS ((ushort)0x0fff) /* All status bits */
+
+/* enhanced buffer descriptor control/status used by Ethernet transmit */
+#define BD_ENET_TX_INT 0x40000000
+#define BD_ENET_TX_TS 0x20000000
+#define BD_ENET_TX_PINS 0x10000000
+#define BD_ENET_TX_IINS 0x08000000
+
+
+/* This device has up to three irqs on some platforms */
+#define FEC_IRQ_NUM 3
+
+/* Maximum number of queues supported
+ * ENET with AVB IP can support up to 3 independent tx queues and rx queues.
+ * User can point the queue number that is less than or equal to 3.
+ */
+#define FEC_ENET_MAX_TX_QS 3
+#define FEC_ENET_MAX_RX_QS 3
+
+#define FEC_R_DES_START(X) (((X) == 1) ? FEC_R_DES_START_1 : \
+ (((X) == 2) ? \
+ FEC_R_DES_START_2 : FEC_R_DES_START_0))
+#define FEC_X_DES_START(X) (((X) == 1) ? FEC_X_DES_START_1 : \
+ (((X) == 2) ? \
+ FEC_X_DES_START_2 : FEC_X_DES_START_0))
+#define FEC_R_BUFF_SIZE(X) (((X) == 1) ? FEC_R_BUFF_SIZE_1 : \
+ (((X) == 2) ? \
+ FEC_R_BUFF_SIZE_2 : FEC_R_BUFF_SIZE_0))
+
+#define FEC_DMA_CFG(X) (((X) == 2) ? FEC_DMA_CFG_2 : FEC_DMA_CFG_1)
+
+#define DMA_CLASS_EN (1 << 16)
+#define FEC_RCMR(X) (((X) == 2) ? FEC_RCMR_2 : FEC_RCMR_1)
+#define IDLE_SLOPE_MASK 0xffff
+#define IDLE_SLOPE_1 0x200 /* BW fraction: 0.5 */
+#define IDLE_SLOPE_2 0x200 /* BW fraction: 0.5 */
+#define IDLE_SLOPE(X) (((X) == 1) ? \
+ (IDLE_SLOPE_1 & IDLE_SLOPE_MASK) : \
+ (IDLE_SLOPE_2 & IDLE_SLOPE_MASK))
+#define RCMR_MATCHEN (0x1 << 16)
+#define RCMR_CMP_CFG(v, n) (((v) & 0x7) << (n << 2))
+#define RCMR_CMP_1 (RCMR_CMP_CFG(0, 0) | RCMR_CMP_CFG(1, 1) | \
+ RCMR_CMP_CFG(2, 2) | RCMR_CMP_CFG(3, 3))
+#define RCMR_CMP_2 (RCMR_CMP_CFG(4, 0) | RCMR_CMP_CFG(5, 1) | \
+ RCMR_CMP_CFG(6, 2) | RCMR_CMP_CFG(7, 3))
+#define RCMR_CMP(X) (((X) == 1) ? RCMR_CMP_1 : RCMR_CMP_2)
+#define FEC_TX_BD_FTYPE(X) (((X) & 0xf) << 20)
+
+/* The number of Tx and Rx buffers. These are allocated from the page
+ * pool. The code may assume these are power of two, so it it best
+ * to keep them that size.
+ * We don't need to allocate pages for the transmitter. We just use
+ * the skbuffer directly.
+ */
+
+#define FEC_ENET_RX_PAGES 256
+#define FEC_ENET_RX_FRSIZE 2048
+#define FEC_ENET_RX_FRPPG (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
+#define RX_RING_SIZE (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
+#define FEC_ENET_TX_FRSIZE 2048
+#define FEC_ENET_TX_FRPPG (PAGE_SIZE / FEC_ENET_TX_FRSIZE)
+#define TX_RING_SIZE 512 /* Must be power of two */
+#define TX_RING_MOD_MASK 511 /* for this to work */
+
+#define BD_ENET_RX_INT 0x00800000
+#define BD_ENET_RX_PTP ((ushort)0x0400)
+#define BD_ENET_RX_ICE 0x00000020
+#define BD_ENET_RX_PCR 0x00000010
+#define FLAG_RX_CSUM_ENABLED (BD_ENET_RX_ICE | BD_ENET_RX_PCR)
+#define FLAG_RX_CSUM_ERROR (BD_ENET_RX_ICE | BD_ENET_RX_PCR)
+
+/* Interrupt events/masks. */
+#define FEC_ENET_HBERR ((uint)0x80000000) /* Heartbeat error */
+#define FEC_ENET_BABR ((uint)0x40000000) /* Babbling receiver */
+#define FEC_ENET_BABT ((uint)0x20000000) /* Babbling transmitter */
+#define FEC_ENET_GRA ((uint)0x10000000) /* Graceful stop complete */
+#define FEC_ENET_TXF_0 ((uint)0x08000000) /* Full frame transmitted */
+#define FEC_ENET_TXF_1 ((uint)0x00000008) /* Full frame transmitted */
+#define FEC_ENET_TXF_2 ((uint)0x00000080) /* Full frame transmitted */
+#define FEC_ENET_TXB ((uint)0x04000000) /* A buffer was transmitted */
+#define FEC_ENET_RXF_0 ((uint)0x02000000) /* Full frame received */
+#define FEC_ENET_RXF_1 ((uint)0x00000002) /* Full frame received */
+#define FEC_ENET_RXF_2 ((uint)0x00000020) /* Full frame received */
+#define FEC_ENET_RXB ((uint)0x01000000) /* A buffer was received */
+#define FEC_ENET_MII ((uint)0x00800000) /* MII interrupt */
+#define FEC_ENET_EBERR ((uint)0x00400000) /* SDMA bus error */
+#define FEC_ENET_WAKEUP ((uint)0x00020000) /* Wakeup request */
+#define FEC_ENET_TXF (FEC_ENET_TXF_0 | FEC_ENET_TXF_1 | FEC_ENET_TXF_2)
+#define FEC_ENET_RXF (FEC_ENET_RXF_0 | FEC_ENET_RXF_1 | FEC_ENET_RXF_2)
+#define FEC_ENET_TS_AVAIL ((uint)0x00010000)
+#define FEC_ENET_TS_TIMER ((uint)0x00008000)
+
+#define FEC_DEFAULT_IMASK (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII)
+#define FEC_NAPI_IMASK FEC_ENET_MII
+#define FEC_RX_DISABLED_IMASK (FEC_DEFAULT_IMASK & (~FEC_ENET_RXF))
+
+/* ENET interrupt coalescing macro define */
+#define FEC_ITR_CLK_SEL (0x1 << 30)
+#define FEC_ITR_EN (0x1 << 31)
+#define FEC_ITR_ICFT(X) (((X) & 0xff) << 20)
+#define FEC_ITR_ICTT(X) ((X) & 0xffff)
+#define FEC_ITR_ICFT_DEFAULT 200 /* Set 200 frame count threshold */
+#define FEC_ITR_ICTT_DEFAULT 1000 /* Set 1000us timer threshold */
+
+#define FEC_VLAN_TAG_LEN 0x04
+#define FEC_ETHTYPE_LEN 0x02
+
+/* Controller is ENET-MAC */
+#define FEC_QUIRK_ENET_MAC (1 << 0)
+/* Controller needs driver to swap frame */
+#define FEC_QUIRK_SWAP_FRAME (1 << 1)
+/* Controller uses gasket */
+#define FEC_QUIRK_USE_GASKET (1 << 2)
+/* Controller has GBIT support */
+#define FEC_QUIRK_HAS_GBIT (1 << 3)
+/* Controller has extend desc buffer */
+#define FEC_QUIRK_HAS_BUFDESC_EX (1 << 4)
+/* Controller has hardware checksum support */
+#define FEC_QUIRK_HAS_CSUM (1 << 5)
+/* Controller has hardware vlan support */
+#define FEC_QUIRK_HAS_VLAN (1 << 6)
+/* ENET IP errata ERR006358
+ *
+ * If the ready bit in the transmit buffer descriptor (TxBD[R]) is previously
+ * detected as not set during a prior frame transmission, then the
+ * ENET_TDAR[TDAR] bit is cleared at a later time, even if additional TxBDs
+ * were added to the ring and the ENET_TDAR[TDAR] bit is set. This results in
+ * frames not being transmitted until there is a 0-to-1 transition on
+ * ENET_TDAR[TDAR].
+ */
+#define FEC_QUIRK_ERR006358 (1 << 7)
+/* ENET IP hw AVB
+ *
+ * i.MX6SX ENET IP add Audio Video Bridging (AVB) feature support.
+ * - Two class indicators on receive with configurable priority
+ * - Two class indicators and line speed timer on transmit allowing
+ * implementation class credit based shapers externally
+ * - Additional DMA registers provisioned to allow managing up to 3
+ * independent rings
+ */
+#define FEC_QUIRK_HAS_AVB (1 << 8)
+/* There is a TDAR race condition for mutliQ when the software sets TDAR
+ * and the UDMA clears TDAR simultaneously or in a small window (2-4 cycles).
+ * This will cause the udma_tx and udma_tx_arbiter state machines to hang.
+ * The issue exist at i.MX6SX enet IP.
+ */
+#define FEC_QUIRK_ERR007885 (1 << 9)
+/* ENET Block Guide/ Chapter for the iMX6SX (PELE) address one issue:
+ * After set ENET_ATCR[Capture], there need some time cycles before the counter
+ * value is capture in the register clock domain.
+ * The wait-time-cycles is at least 6 clock cycles of the slower clock between
+ * the register clock and the 1588 clock. The 1588 ts_clk is fixed to 25Mhz,
+ * register clock is 66Mhz, so the wait-time-cycles must be greater than 240ns
+ * (40ns * 6).
+ */
+#define FEC_QUIRK_BUG_CAPTURE (1 << 10)
+/* Controller has only one MDIO bus */
+#define FEC_QUIRK_SINGLE_MDIO (1 << 11)
+/* Controller supports RACC register */
+#define FEC_QUIRK_HAS_RACC (1 << 12)
+/* Controller supports interrupt coalesc */
+#define FEC_QUIRK_HAS_COALESCE (1 << 13)
+/* Interrupt doesn't wake CPU from deep idle */
+#define FEC_QUIRK_ERR006687 (1 << 14)
+/* The MIB counters should be cleared and enabled during
+ * initialisation.
+ */
+#define FEC_QUIRK_MIB_CLEAR (1 << 15)
+
+struct bufdesc_prop {
+ int qid;
+ /* Address of Rx and Tx buffers */
+ struct bufdesc *base;
+ struct bufdesc *last;
+ struct bufdesc *cur;
+ void __iomem *reg_desc_active;
+ dma_addr_t dma;
+ unsigned short ring_size;
+ unsigned char dsize;
+ unsigned char dsize_log2;
+};
+
+struct fec_enet_priv_tx_q {
+ struct bufdesc_prop bd;
+ unsigned char *tx_bounce[TX_RING_SIZE];
+ union { /* CAUTION: must be same cell count. */
+ struct sk_buff *tx_skbuff[TX_RING_SIZE];
+ struct rtskb *tx_rtbuff[TX_RING_SIZE];
+ };
+
+ unsigned short tx_stop_threshold;
+ unsigned short tx_wake_threshold;
+
+ struct bufdesc *dirty_tx;
+ char *tso_hdrs;
+ dma_addr_t tso_hdrs_dma;
+};
+
+struct fec_enet_priv_rx_q {
+ struct bufdesc_prop bd;
+ union { /* CAUTION: must be same cell count. */
+ struct sk_buff *rx_skbuff[RX_RING_SIZE];
+ struct rtskb *rx_rtbuff[RX_RING_SIZE];
+ };
+};
+
+/* The FEC buffer descriptors track the ring buffers. The rx_bd_base and
+ * tx_bd_base always point to the base of the buffer descriptors. The
+ * cur_rx and cur_tx point to the currently available buffer.
+ * The dirty_tx tracks the current buffer that is being sent by the
+ * controller. The cur_tx and dirty_tx are equal under both completely
+ * empty and completely full conditions. The empty/ready indicator in
+ * the buffer descriptor determines the actual condition.
+ */
+struct fec_enet_private {
+ /* Hardware registers of the FEC device */
+ void __iomem *hwp;
+
+ struct net_device *netdev;
+
+ struct fec_rt_data {
+ rtdm_irq_t irq_handle[3];
+ rtdm_lock_t lock;
+ rtdm_nrtsig_t mdio_sig;
+ struct rtnet_device dev;
+ bool enabled;
+ } rtnet;
+
+ struct clk *clk_ipg;
+ struct clk *clk_ahb;
+ struct clk *clk_ref;
+ struct clk *clk_enet_out;
+ struct clk *clk_ptp;
+
+ bool ptp_clk_on;
+ struct mutex ptp_clk_mutex;
+ unsigned int num_tx_queues;
+ unsigned int num_rx_queues;
+
+ /* The saved address of a sent-in-place packet/buffer, for skfree(). */
+ struct fec_enet_priv_tx_q *tx_queue[FEC_ENET_MAX_TX_QS];
+ struct fec_enet_priv_rx_q *rx_queue[FEC_ENET_MAX_RX_QS];
+
+ unsigned int total_tx_ring_size;
+ unsigned int total_rx_ring_size;
+
+ unsigned long work_tx;
+ unsigned long work_rx;
+ unsigned long work_ts;
+ unsigned long work_mdio;
+
+ struct platform_device *pdev;
+
+ int dev_id;
+
+ /* Phylib and MDIO interface */
+ struct mii_bus *mii_bus;
+ int mii_timeout;
+ uint phy_speed;
+ phy_interface_t phy_interface;
+ struct device_node *phy_node;
+ int link;
+ int full_duplex;
+ int speed;
+ struct completion mdio_done;
+ int irq[FEC_IRQ_NUM];
+ int irqnr;
+ bool bufdesc_ex;
+ int pause_flag;
+ int wol_flag;
+ u32 quirks;
+
+ struct napi_struct napi;
+ int csum_flags;
+
+ struct work_struct tx_timeout_work;
+
+ struct ptp_clock *ptp_clock;
+ struct ptp_clock_info ptp_caps;
+ unsigned long last_overflow_check;
+ spinlock_t tmreg_lock;
+ struct cyclecounter cc;
+ struct timecounter tc;
+ int rx_hwtstamp_filter;
+ u32 base_incval;
+ u32 cycle_speed;
+ int hwts_rx_en;
+ int hwts_tx_en;
+ struct delayed_work time_keep;
+ struct regulator *reg_phy;
+
+ unsigned int tx_align;
+ unsigned int rx_align;
+
+ /* hw interrupt coalesce */
+ unsigned int rx_pkts_itr;
+ unsigned int rx_time_itr;
+ unsigned int tx_pkts_itr;
+ unsigned int tx_time_itr;
+ unsigned int itr_clk_rate;
+
+ u32 rx_copybreak;
+
+ /* ptp clock period in ns*/
+ unsigned int ptp_inc;
+
+ /* pps */
+ int pps_channel;
+ unsigned int reload_period;
+ int pps_enable;
+ unsigned int next_counter;
+
+ u64 ethtool_stats[0];
+};
+
+void fec_ptp_init(struct platform_device *pdev);
+void fec_ptp_stop(struct platform_device *pdev);
+void fec_ptp_start_cyclecounter(struct net_device *ndev);
+int fec_ptp_set(struct net_device *ndev, struct ifreq *ifr);
+int fec_ptp_get(struct net_device *ndev, struct ifreq *ifr);
+uint fec_ptp_check_pps_event(struct fec_enet_private *fep);
+
+/****************************************************************************/
+#endif /* FEC_H */
diff --git a/kernel/drivers/net/drivers/freescale/fec_main.c b/kernel/drivers/net/drivers/freescale/fec_main.c
new file mode 100644
index 000000000..08956dfab
--- /dev/null
+++ b/kernel/drivers/net/drivers/freescale/fec_main.c
@@ -0,0 +1,4394 @@
+/*
+ * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
+ * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
+ *
+ * Right now, I am very wasteful with the buffers. I allocate memory
+ * pages and then divide them into 2K frame buffers. This way I know I
+ * have buffers large enough to hold one frame within one buffer descriptor.
+ * Once I get this working, I will use 64 or 128 byte CPM buffers, which
+ * will be much more memory efficient and will easily handle lots of
+ * small packets.
+ *
+ * Much better multiple PHY support by Magnus Damm.
+ * Copyright (c) 2000 Ericsson Radio Systems AB.
+ *
+ * Support for FEC controller of ColdFire processors.
+ * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
+ *
+ * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
+ * Copyright (c) 2004-2006 Macq Electronique SA.
+ *
+ * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/pm_runtime.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <net/ip.h>
+#include <net/tso.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include <linux/icmp.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/bitops.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <linux/mdio.h>
+#include <linux/phy.h>
+#include <linux/fec.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_mdio.h>
+#include <linux/of_net.h>
+#include <linux/regulator/consumer.h>
+#include <linux/if_vlan.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/prefetch.h>
+#include <soc/imx/cpuidle.h>
+
+#include <asm/cacheflush.h>
+
+#include "fec.h"
+
+static bool rtnet_disabled;
+module_param_named(rtnet_disabled, rtnet_disabled, bool, 0444);
+
+static void set_multicast_list(struct net_device *ndev);
+static void fec_enet_itr_coal_init(struct net_device *ndev);
+
+#define DRIVER_NAME "rtnet_fec"
+
+#define FEC_ENET_GET_QUQUE(_x) ((_x == 0) ? 1 : ((_x == 1) ? 2 : 0))
+
+/* Pause frame feild and FIFO threshold */
+#define FEC_ENET_FCE (1 << 5)
+#define FEC_ENET_RSEM_V 0x84
+#define FEC_ENET_RSFL_V 16
+#define FEC_ENET_RAEM_V 0x8
+#define FEC_ENET_RAFL_V 0x8
+#define FEC_ENET_OPD_V 0xFFF0
+#define FEC_MDIO_PM_TIMEOUT 100 /* ms */
+
+static struct platform_device_id fec_devtype[] = {
+ {
+ /* keep it for coldfire */
+ .name = DRIVER_NAME,
+ .driver_data = 0,
+ }, {
+ .name = "imx25-fec",
+ .driver_data = FEC_QUIRK_USE_GASKET | FEC_QUIRK_MIB_CLEAR,
+ }, {
+ .name = "imx27-fec",
+ .driver_data = FEC_QUIRK_MIB_CLEAR,
+ }, {
+ .name = "imx28-fec",
+ .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME |
+ FEC_QUIRK_SINGLE_MDIO | FEC_QUIRK_HAS_RACC,
+ }, {
+ .name = "imx6q-fec",
+ .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
+ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
+ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR006358 |
+ FEC_QUIRK_HAS_RACC,
+ }, {
+ .name = "mvf600-fec",
+ .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_RACC,
+ }, {
+ .name = "imx6sx-fec",
+ .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
+ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
+ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB |
+ FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE |
+ FEC_QUIRK_HAS_RACC | FEC_QUIRK_HAS_COALESCE,
+ }, {
+ .name = "imx6ul-fec",
+ .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
+ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
+ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR007885 |
+ FEC_QUIRK_BUG_CAPTURE | FEC_QUIRK_HAS_RACC |
+ FEC_QUIRK_HAS_COALESCE,
+ }, {
+ /* sentinel */
+ }
+};
+MODULE_DEVICE_TABLE(platform, fec_devtype);
+
+enum imx_fec_type {
+ IMX25_FEC = 1, /* runs on i.mx25/50/53 */
+ IMX27_FEC, /* runs on i.mx27/35/51 */
+ IMX28_FEC,
+ IMX6Q_FEC,
+ MVF600_FEC,
+ IMX6SX_FEC,
+ IMX6UL_FEC,
+};
+
+static const struct of_device_id fec_dt_ids[] = {
+ { .compatible = "fsl,imx25-fec", .data = &fec_devtype[IMX25_FEC], },
+ { .compatible = "fsl,imx27-fec", .data = &fec_devtype[IMX27_FEC], },
+ { .compatible = "fsl,imx28-fec", .data = &fec_devtype[IMX28_FEC], },
+ { .compatible = "fsl,imx6q-fec", .data = &fec_devtype[IMX6Q_FEC], },
+ { .compatible = "fsl,mvf600-fec", .data = &fec_devtype[MVF600_FEC], },
+ { .compatible = "fsl,imx6sx-fec", .data = &fec_devtype[IMX6SX_FEC], },
+ { .compatible = "fsl,imx6ul-fec", .data = &fec_devtype[IMX6UL_FEC], },
+ { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, fec_dt_ids);
+
+static unsigned char macaddr[ETH_ALEN];
+module_param_array(macaddr, byte, NULL, 0);
+MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
+
+#if defined(CONFIG_M5272)
+/*
+ * Some hardware gets it MAC address out of local flash memory.
+ * if this is non-zero then assume it is the address to get MAC from.
+ */
+#if defined(CONFIG_NETtel)
+#define FEC_FLASHMAC 0xf0006006
+#elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
+#define FEC_FLASHMAC 0xf0006000
+#elif defined(CONFIG_CANCam)
+#define FEC_FLASHMAC 0xf0020000
+#elif defined (CONFIG_M5272C3)
+#define FEC_FLASHMAC (0xffe04000 + 4)
+#elif defined(CONFIG_MOD5272)
+#define FEC_FLASHMAC 0xffc0406b
+#else
+#define FEC_FLASHMAC 0
+#endif
+#endif /* CONFIG_M5272 */
+
+/* The FEC stores dest/src/type/vlan, data, and checksum for receive packets.
+ *
+ * 2048 byte skbufs are allocated. However, alignment requirements
+ * varies between FEC variants. Worst case is 64, so round down by 64.
+ */
+#define PKT_MAXBUF_SIZE (round_down(2048 - 64, 64))
+#define PKT_MINBUF_SIZE 64
+
+/* FEC receive acceleration */
+#define FEC_RACC_IPDIS (1 << 1)
+#define FEC_RACC_PRODIS (1 << 2)
+#define FEC_RACC_SHIFT16 BIT(7)
+#define FEC_RACC_OPTIONS (FEC_RACC_IPDIS | FEC_RACC_PRODIS)
+
+/* MIB Control Register */
+#define FEC_MIB_CTRLSTAT_DISABLE BIT(31)
+
+/*
+ * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
+ * size bits. Other FEC hardware does not, so we need to take that into
+ * account when setting it.
+ */
+#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
+ defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
+#define OPT_FRAME_SIZE (PKT_MAXBUF_SIZE << 16)
+#else
+#define OPT_FRAME_SIZE 0
+#endif
+
+/* FEC MII MMFR bits definition */
+#define FEC_MMFR_ST (1 << 30)
+#define FEC_MMFR_OP_READ (2 << 28)
+#define FEC_MMFR_OP_WRITE (1 << 28)
+#define FEC_MMFR_PA(v) ((v & 0x1f) << 23)
+#define FEC_MMFR_RA(v) ((v & 0x1f) << 18)
+#define FEC_MMFR_TA (2 << 16)
+#define FEC_MMFR_DATA(v) (v & 0xffff)
+/* FEC ECR bits definition */
+#define FEC_ECR_MAGICEN (1 << 2)
+#define FEC_ECR_SLEEP (1 << 3)
+
+#define FEC_MII_TIMEOUT 30000 /* us */
+
+/* Transmitter timeout */
+#define TX_TIMEOUT (2 * HZ)
+
+#define FEC_PAUSE_FLAG_AUTONEG 0x1
+#define FEC_PAUSE_FLAG_ENABLE 0x2
+#define FEC_WOL_HAS_MAGIC_PACKET (0x1 << 0)
+#define FEC_WOL_FLAG_ENABLE (0x1 << 1)
+#define FEC_WOL_FLAG_SLEEP_ON (0x1 << 2)
+
+#define COPYBREAK_DEFAULT 256
+
+/* Max number of allowed TCP segments for software TSO */
+#define FEC_MAX_TSO_SEGS 100
+#define FEC_MAX_SKB_DESCS (FEC_MAX_TSO_SEGS * 2 + MAX_SKB_FRAGS)
+
+#define IS_TSO_HEADER(txq, addr) \
+ ((addr >= txq->tso_hdrs_dma) && \
+ (addr < txq->tso_hdrs_dma + txq->bd.ring_size * TSO_HEADER_SIZE))
+
+static int mii_cnt;
+
+static inline bool if_running(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ if (frt->enabled)
+ return rtnetif_running(&frt->dev);
+
+ return netif_running(ndev);
+}
+
+static inline void if_tx_lock(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ if (frt->enabled) {
+ rtnetif_stop_queue(&frt->dev);
+ return;
+ }
+
+ netif_tx_lock_bh(ndev);
+}
+
+static inline void if_lock(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ if (frt->enabled) {
+ rtnetif_stop_queue(&frt->dev);
+ return;
+ }
+
+ napi_disable(&fep->napi);
+ netif_tx_lock_bh(ndev);
+}
+
+static inline void if_tx_unlock(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ if (frt->enabled) {
+ rtnetif_wake_queue(&frt->dev);
+ return;
+ }
+
+ netif_tx_unlock_bh(ndev);
+}
+
+static inline void if_unlock(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ if (frt->enabled) {
+ rtnetif_wake_queue(&frt->dev);
+ return;
+ }
+
+ netif_tx_unlock_bh(ndev);
+ napi_enable(&fep->napi);
+}
+
+static inline void if_wake_unlock(struct net_device *ndev, bool all)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ if (frt->enabled) {
+ rtnetif_wake_queue(&frt->dev);
+ return;
+ }
+
+ if (all)
+ netif_tx_wake_all_queues(ndev);
+ else
+ netif_wake_queue(ndev);
+
+ netif_tx_unlock_bh(ndev);
+ napi_enable(&fep->napi);
+}
+
+static struct bufdesc *fec_enet_get_nextdesc(struct bufdesc *bdp,
+ struct bufdesc_prop *bd)
+{
+ return (bdp >= bd->last) ? bd->base
+ : (struct bufdesc *)(((void *)bdp) + bd->dsize);
+}
+
+static struct bufdesc *fec_enet_get_prevdesc(struct bufdesc *bdp,
+ struct bufdesc_prop *bd)
+{
+ return (bdp <= bd->base) ? bd->last
+ : (struct bufdesc *)(((void *)bdp) - bd->dsize);
+}
+
+static int fec_enet_get_bd_index(struct bufdesc *bdp,
+ struct bufdesc_prop *bd)
+{
+ return ((const char *)bdp - (const char *)bd->base) >> bd->dsize_log2;
+}
+
+static int fec_enet_get_free_txdesc_num(struct fec_enet_priv_tx_q *txq)
+{
+ int entries;
+
+ entries = (((const char *)txq->dirty_tx -
+ (const char *)txq->bd.cur) >> txq->bd.dsize_log2) - 1;
+
+ return entries >= 0 ? entries : entries + txq->bd.ring_size;
+}
+
+static void swap_buffer(void *bufaddr, int len)
+{
+ int i;
+ unsigned int *buf = bufaddr;
+
+ for (i = 0; i < len; i += 4, buf++)
+ swab32s(buf);
+}
+
+static void swap_buffer2(void *dst_buf, void *src_buf, int len)
+{
+ int i;
+ unsigned int *src = src_buf;
+ unsigned int *dst = dst_buf;
+
+ for (i = 0; i < len; i += 4, src++, dst++)
+ *dst = swab32p(src);
+}
+
+static void fec_dump(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct bufdesc *bdp;
+ struct fec_enet_priv_tx_q *txq;
+ int index = 0;
+
+ netdev_info(ndev, "TX ring dump\n");
+ pr_info("Nr SC addr len SKB\n");
+
+ txq = fep->tx_queue[0];
+ bdp = txq->bd.base;
+
+ do {
+ pr_info("%3u %c%c 0x%04x 0x%08x %4u %p\n",
+ index,
+ bdp == txq->bd.cur ? 'S' : ' ',
+ bdp == txq->dirty_tx ? 'H' : ' ',
+ fec16_to_cpu(bdp->cbd_sc),
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ fec16_to_cpu(bdp->cbd_datlen),
+ txq->tx_skbuff[index]);
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+ index++;
+ } while (bdp != txq->bd.base);
+}
+
+static inline bool is_ipv4_pkt(struct sk_buff *skb)
+{
+ return skb->protocol == htons(ETH_P_IP) && ip_hdr(skb)->version == 4;
+}
+
+static int
+fec_enet_clear_csum(struct sk_buff *skb, struct net_device *ndev)
+{
+ /* Only run for packets requiring a checksum. */
+ if (skb->ip_summed != CHECKSUM_PARTIAL)
+ return 0;
+
+ if (unlikely(skb_cow_head(skb, 0)))
+ return -1;
+
+ if (is_ipv4_pkt(skb))
+ ip_hdr(skb)->check = 0;
+ *(__sum16 *)(skb->head + skb->csum_start + skb->csum_offset) = 0;
+
+ return 0;
+}
+
+static struct bufdesc *
+fec_enet_txq_submit_frag_skb(struct fec_enet_priv_tx_q *txq,
+ struct sk_buff *skb,
+ struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct bufdesc *bdp = txq->bd.cur;
+ struct bufdesc_ex *ebdp;
+ int nr_frags = skb_shinfo(skb)->nr_frags;
+ int frag, frag_len;
+ unsigned short status;
+ unsigned int estatus = 0;
+ skb_frag_t *this_frag;
+ unsigned int index;
+ void *bufaddr;
+ dma_addr_t addr;
+ int i;
+
+ for (frag = 0; frag < nr_frags; frag++) {
+ this_frag = &skb_shinfo(skb)->frags[frag];
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+ ebdp = (struct bufdesc_ex *)bdp;
+
+ status = fec16_to_cpu(bdp->cbd_sc);
+ status &= ~BD_ENET_TX_STATS;
+ status |= (BD_ENET_TX_TC | BD_ENET_TX_READY);
+ frag_len = skb_shinfo(skb)->frags[frag].size;
+
+ /* Handle the last BD specially */
+ if (frag == nr_frags - 1) {
+ status |= (BD_ENET_TX_INTR | BD_ENET_TX_LAST);
+ if (fep->bufdesc_ex) {
+ estatus |= BD_ENET_TX_INT;
+ if (unlikely(skb_shinfo(skb)->tx_flags &
+ SKBTX_HW_TSTAMP && fep->hwts_tx_en))
+ estatus |= BD_ENET_TX_TS;
+ }
+ }
+
+ if (fep->bufdesc_ex) {
+ if (fep->quirks & FEC_QUIRK_HAS_AVB)
+ estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
+ if (skb->ip_summed == CHECKSUM_PARTIAL)
+ estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
+ ebdp->cbd_bdu = 0;
+ ebdp->cbd_esc = cpu_to_fec32(estatus);
+ }
+
+ bufaddr = page_address(this_frag->page.p) + this_frag->page_offset;
+
+ index = fec_enet_get_bd_index(bdp, &txq->bd);
+ if (((unsigned long) bufaddr) & fep->tx_align ||
+ fep->quirks & FEC_QUIRK_SWAP_FRAME) {
+ memcpy(txq->tx_bounce[index], bufaddr, frag_len);
+ bufaddr = txq->tx_bounce[index];
+
+ if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
+ swap_buffer(bufaddr, frag_len);
+ }
+
+ addr = dma_map_single(&fep->pdev->dev, bufaddr, frag_len,
+ DMA_TO_DEVICE);
+ if (dma_mapping_error(&fep->pdev->dev, addr)) {
+ if (net_ratelimit())
+ netdev_err(ndev, "Tx DMA memory map failed\n");
+ goto dma_mapping_error;
+ }
+
+ bdp->cbd_bufaddr = cpu_to_fec32(addr);
+ bdp->cbd_datlen = cpu_to_fec16(frag_len);
+ /* Make sure the updates to rest of the descriptor are
+ * performed before transferring ownership.
+ */
+ wmb();
+ bdp->cbd_sc = cpu_to_fec16(status);
+ }
+
+ return bdp;
+dma_mapping_error:
+ bdp = txq->bd.cur;
+ for (i = 0; i < frag; i++) {
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+ dma_unmap_single(&fep->pdev->dev, fec32_to_cpu(bdp->cbd_bufaddr),
+ fec16_to_cpu(bdp->cbd_datlen), DMA_TO_DEVICE);
+ }
+ return ERR_PTR(-ENOMEM);
+}
+
+static int fec_enet_txq_submit_skb(struct fec_enet_priv_tx_q *txq,
+ struct sk_buff *skb, struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int nr_frags = skb_shinfo(skb)->nr_frags;
+ struct bufdesc *bdp, *last_bdp;
+ void *bufaddr;
+ dma_addr_t addr;
+ unsigned short status;
+ unsigned short buflen;
+ unsigned int estatus = 0;
+ unsigned int index;
+ int entries_free;
+
+ entries_free = fec_enet_get_free_txdesc_num(txq);
+ if (entries_free < MAX_SKB_FRAGS + 1) {
+ dev_kfree_skb_any(skb);
+ if (net_ratelimit())
+ netdev_err(ndev, "NOT enough BD for SG!\n");
+ return NETDEV_TX_OK;
+ }
+
+ /* Protocol checksum off-load for TCP and UDP. */
+ if (fec_enet_clear_csum(skb, ndev)) {
+ dev_kfree_skb_any(skb);
+ return NETDEV_TX_OK;
+ }
+
+ /* Fill in a Tx ring entry */
+ bdp = txq->bd.cur;
+ last_bdp = bdp;
+ status = fec16_to_cpu(bdp->cbd_sc);
+ status &= ~BD_ENET_TX_STATS;
+
+ /* Set buffer length and buffer pointer */
+ bufaddr = skb->data;
+ buflen = skb_headlen(skb);
+
+ index = fec_enet_get_bd_index(bdp, &txq->bd);
+ if (((unsigned long) bufaddr) & fep->tx_align ||
+ fep->quirks & FEC_QUIRK_SWAP_FRAME) {
+ memcpy(txq->tx_bounce[index], skb->data, buflen);
+ bufaddr = txq->tx_bounce[index];
+
+ if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
+ swap_buffer(bufaddr, buflen);
+ }
+
+ /* Push the data cache so the CPM does not get stale memory data. */
+ addr = dma_map_single(&fep->pdev->dev, bufaddr, buflen, DMA_TO_DEVICE);
+ if (dma_mapping_error(&fep->pdev->dev, addr)) {
+ dev_kfree_skb_any(skb);
+ if (net_ratelimit())
+ netdev_err(ndev, "Tx DMA memory map failed\n");
+ return NETDEV_TX_OK;
+ }
+
+ if (nr_frags) {
+ last_bdp = fec_enet_txq_submit_frag_skb(txq, skb, ndev);
+ if (IS_ERR(last_bdp)) {
+ dma_unmap_single(&fep->pdev->dev, addr,
+ buflen, DMA_TO_DEVICE);
+ dev_kfree_skb_any(skb);
+ return NETDEV_TX_OK;
+ }
+ } else {
+ status |= (BD_ENET_TX_INTR | BD_ENET_TX_LAST);
+ if (fep->bufdesc_ex) {
+ estatus = BD_ENET_TX_INT;
+ if (unlikely(skb_shinfo(skb)->tx_flags &
+ SKBTX_HW_TSTAMP && fep->hwts_tx_en))
+ estatus |= BD_ENET_TX_TS;
+ }
+ }
+ bdp->cbd_bufaddr = cpu_to_fec32(addr);
+ bdp->cbd_datlen = cpu_to_fec16(buflen);
+
+ if (fep->bufdesc_ex) {
+
+ struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
+
+ if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
+ fep->hwts_tx_en))
+ skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
+
+ if (fep->quirks & FEC_QUIRK_HAS_AVB)
+ estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
+
+ if (skb->ip_summed == CHECKSUM_PARTIAL)
+ estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
+
+ ebdp->cbd_bdu = 0;
+ ebdp->cbd_esc = cpu_to_fec32(estatus);
+ }
+
+ index = fec_enet_get_bd_index(last_bdp, &txq->bd);
+ /* Save skb pointer */
+ txq->tx_skbuff[index] = skb;
+
+ /* Make sure the updates to rest of the descriptor are performed before
+ * transferring ownership.
+ */
+ wmb();
+
+ /* Send it on its way. Tell FEC it's ready, interrupt when done,
+ * it's the last BD of the frame, and to put the CRC on the end.
+ */
+ status |= (BD_ENET_TX_READY | BD_ENET_TX_TC);
+ bdp->cbd_sc = cpu_to_fec16(status);
+
+ /* If this was the last BD in the ring, start at the beginning again. */
+ bdp = fec_enet_get_nextdesc(last_bdp, &txq->bd);
+
+ skb_tx_timestamp(skb);
+
+ /* Make sure the update to bdp and tx_skbuff are performed before
+ * txq->bd.cur.
+ */
+ wmb();
+ txq->bd.cur = bdp;
+
+ /* Trigger transmission start */
+ writel(0, txq->bd.reg_desc_active);
+
+ return 0;
+}
+
+static int fec_rt_txq_submit_skb(struct fec_enet_priv_tx_q *txq,
+ struct rtskb *skb, struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ struct bufdesc *bdp, *last_bdp;
+ void *bufaddr;
+ dma_addr_t addr;
+ unsigned short status;
+ unsigned short buflen;
+ unsigned int estatus = 0;
+ unsigned int index;
+ int entries_free;
+ rtdm_lockctx_t c;
+
+ entries_free = fec_enet_get_free_txdesc_num(txq);
+ if (entries_free < MAX_SKB_FRAGS + 1) {
+ rtdm_printk_ratelimited("%s: NOT enough BD for SG!\n",
+ dev_name(&fep->pdev->dev));
+ return NETDEV_TX_BUSY;
+ }
+
+ rtdm_lock_get_irqsave(&frt->lock, c);
+
+ if (skb->xmit_stamp)
+ *skb->xmit_stamp =
+ cpu_to_be64(rtdm_clock_read_monotonic() +
+ *skb->xmit_stamp);
+
+ /* Fill in a Tx ring entry */
+ bdp = txq->bd.cur;
+ last_bdp = bdp;
+ status = fec16_to_cpu(bdp->cbd_sc);
+ status &= ~BD_ENET_TX_STATS;
+
+ /* Set buffer length and buffer pointer */
+ bufaddr = skb->data;
+ buflen = rtskb_headlen(skb);
+
+ index = fec_enet_get_bd_index(bdp, &txq->bd);
+ if (((unsigned long) bufaddr) & fep->tx_align ||
+ fep->quirks & FEC_QUIRK_SWAP_FRAME) {
+ memcpy(txq->tx_bounce[index], skb->data, buflen);
+ bufaddr = txq->tx_bounce[index];
+
+ if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
+ swap_buffer(bufaddr, buflen);
+ }
+
+ addr = dma_map_single(&fep->pdev->dev, bufaddr, buflen, DMA_TO_DEVICE);
+ if (dma_mapping_error(&fep->pdev->dev, addr)) {
+ rtdm_lock_put_irqrestore(&frt->lock, c);
+ dev_kfree_rtskb(skb);
+ rtdm_printk_ratelimited("%s: Tx DMA memory map failed\n",
+ dev_name(&fep->pdev->dev));
+ return NETDEV_TX_BUSY;
+ }
+ status |= (BD_ENET_TX_INTR | BD_ENET_TX_LAST);
+
+ bdp->cbd_bufaddr = cpu_to_fec32(addr);
+ bdp->cbd_datlen = cpu_to_fec16(buflen);
+
+ if (fep->bufdesc_ex) {
+ struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
+ estatus = BD_ENET_TX_INT;
+ if (fep->quirks & FEC_QUIRK_HAS_AVB)
+ estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
+ ebdp->cbd_bdu = 0;
+ ebdp->cbd_esc = cpu_to_fec32(estatus);
+ }
+
+ index = fec_enet_get_bd_index(last_bdp, &txq->bd);
+ txq->tx_rtbuff[index] = skb;
+
+ /* Make sure the updates to rest of the descriptor are performed before
+ * transferring ownership.
+ */
+ wmb();
+
+ /* Send it on its way. Tell FEC it's ready, interrupt when done,
+ * it's the last BD of the frame, and to put the CRC on the end.
+ */
+ status |= (BD_ENET_TX_READY | BD_ENET_TX_TC);
+ bdp->cbd_sc = cpu_to_fec16(status);
+
+ /* If this was the last BD in the ring, start at the beginning again. */
+ bdp = fec_enet_get_nextdesc(last_bdp, &txq->bd);
+
+ /* Make sure the update to bdp and tx_rtbuff are performed
+ * before txq->bd.cur.
+ */
+ wmb();
+ txq->bd.cur = bdp;
+
+ /* Trigger transmission start */
+ writel(0, txq->bd.reg_desc_active);
+
+ rtdm_lock_put_irqrestore(&frt->lock, c);
+
+ return 0;
+}
+
+static int
+fec_enet_txq_put_data_tso(struct fec_enet_priv_tx_q *txq, struct sk_buff *skb,
+ struct net_device *ndev,
+ struct bufdesc *bdp, int index, char *data,
+ int size, bool last_tcp, bool is_last)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct bufdesc_ex *ebdp = container_of(bdp, struct bufdesc_ex, desc);
+ unsigned short status;
+ unsigned int estatus = 0;
+ dma_addr_t addr;
+
+ status = fec16_to_cpu(bdp->cbd_sc);
+ status &= ~BD_ENET_TX_STATS;
+
+ status |= (BD_ENET_TX_TC | BD_ENET_TX_READY);
+
+ if (((unsigned long) data) & fep->tx_align ||
+ fep->quirks & FEC_QUIRK_SWAP_FRAME) {
+ memcpy(txq->tx_bounce[index], data, size);
+ data = txq->tx_bounce[index];
+
+ if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
+ swap_buffer(data, size);
+ }
+
+ addr = dma_map_single(&fep->pdev->dev, data, size, DMA_TO_DEVICE);
+ if (dma_mapping_error(&fep->pdev->dev, addr)) {
+ dev_kfree_skb_any(skb);
+ if (net_ratelimit())
+ netdev_err(ndev, "Tx DMA memory map failed\n");
+ return NETDEV_TX_BUSY;
+ }
+
+ bdp->cbd_datlen = cpu_to_fec16(size);
+ bdp->cbd_bufaddr = cpu_to_fec32(addr);
+
+ if (fep->bufdesc_ex) {
+ if (fep->quirks & FEC_QUIRK_HAS_AVB)
+ estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
+ if (skb->ip_summed == CHECKSUM_PARTIAL)
+ estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
+ ebdp->cbd_bdu = 0;
+ ebdp->cbd_esc = cpu_to_fec32(estatus);
+ }
+
+ /* Handle the last BD specially */
+ if (last_tcp)
+ status |= (BD_ENET_TX_LAST | BD_ENET_TX_TC);
+ if (is_last) {
+ status |= BD_ENET_TX_INTR;
+ if (fep->bufdesc_ex)
+ ebdp->cbd_esc |= cpu_to_fec32(BD_ENET_TX_INT);
+ }
+
+ bdp->cbd_sc = cpu_to_fec16(status);
+
+ return 0;
+}
+
+static int
+fec_enet_txq_put_hdr_tso(struct fec_enet_priv_tx_q *txq,
+ struct sk_buff *skb, struct net_device *ndev,
+ struct bufdesc *bdp, int index)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
+ struct bufdesc_ex *ebdp = container_of(bdp, struct bufdesc_ex, desc);
+ void *bufaddr;
+ unsigned long dmabuf;
+ unsigned short status;
+ unsigned int estatus = 0;
+
+ status = fec16_to_cpu(bdp->cbd_sc);
+ status &= ~BD_ENET_TX_STATS;
+ status |= (BD_ENET_TX_TC | BD_ENET_TX_READY);
+
+ bufaddr = txq->tso_hdrs + index * TSO_HEADER_SIZE;
+ dmabuf = txq->tso_hdrs_dma + index * TSO_HEADER_SIZE;
+ if (((unsigned long)bufaddr) & fep->tx_align ||
+ fep->quirks & FEC_QUIRK_SWAP_FRAME) {
+ memcpy(txq->tx_bounce[index], skb->data, hdr_len);
+ bufaddr = txq->tx_bounce[index];
+
+ if (fep->quirks & FEC_QUIRK_SWAP_FRAME)
+ swap_buffer(bufaddr, hdr_len);
+
+ dmabuf = dma_map_single(&fep->pdev->dev, bufaddr,
+ hdr_len, DMA_TO_DEVICE);
+ if (dma_mapping_error(&fep->pdev->dev, dmabuf)) {
+ dev_kfree_skb_any(skb);
+ if (net_ratelimit())
+ netdev_err(ndev, "Tx DMA memory map failed\n");
+ return NETDEV_TX_BUSY;
+ }
+ }
+
+ bdp->cbd_bufaddr = cpu_to_fec32(dmabuf);
+ bdp->cbd_datlen = cpu_to_fec16(hdr_len);
+
+ if (fep->bufdesc_ex) {
+ if (fep->quirks & FEC_QUIRK_HAS_AVB)
+ estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
+ if (skb->ip_summed == CHECKSUM_PARTIAL)
+ estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
+ ebdp->cbd_bdu = 0;
+ ebdp->cbd_esc = cpu_to_fec32(estatus);
+ }
+
+ bdp->cbd_sc = cpu_to_fec16(status);
+
+ return 0;
+}
+
+static int fec_enet_txq_submit_tso(struct fec_enet_priv_tx_q *txq,
+ struct sk_buff *skb,
+ struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
+ int total_len, data_left;
+ struct bufdesc *bdp = txq->bd.cur;
+ struct tso_t tso;
+ unsigned int index = 0;
+ int ret;
+
+ if (tso_count_descs(skb) >= fec_enet_get_free_txdesc_num(txq)) {
+ dev_kfree_skb_any(skb);
+ if (net_ratelimit())
+ netdev_err(ndev, "NOT enough BD for TSO!\n");
+ return NETDEV_TX_OK;
+ }
+
+ /* Protocol checksum off-load for TCP and UDP. */
+ if (fec_enet_clear_csum(skb, ndev)) {
+ dev_kfree_skb_any(skb);
+ return NETDEV_TX_OK;
+ }
+
+ /* Initialize the TSO handler, and prepare the first payload */
+ tso_start(skb, &tso);
+
+ total_len = skb->len - hdr_len;
+ while (total_len > 0) {
+ char *hdr;
+
+ index = fec_enet_get_bd_index(bdp, &txq->bd);
+ data_left = min_t(int, skb_shinfo(skb)->gso_size, total_len);
+ total_len -= data_left;
+
+ /* prepare packet headers: MAC + IP + TCP */
+ hdr = txq->tso_hdrs + index * TSO_HEADER_SIZE;
+ tso_build_hdr(skb, hdr, &tso, data_left, total_len == 0);
+ ret = fec_enet_txq_put_hdr_tso(txq, skb, ndev, bdp, index);
+ if (ret)
+ goto err_release;
+
+ while (data_left > 0) {
+ int size;
+
+ size = min_t(int, tso.size, data_left);
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+ index = fec_enet_get_bd_index(bdp, &txq->bd);
+ ret = fec_enet_txq_put_data_tso(txq, skb, ndev,
+ bdp, index,
+ tso.data, size,
+ size == data_left,
+ total_len == 0);
+ if (ret)
+ goto err_release;
+
+ data_left -= size;
+ tso_build_data(skb, &tso, size);
+ }
+
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+ }
+
+ /* Save skb pointer */
+ txq->tx_skbuff[index] = skb;
+
+ skb_tx_timestamp(skb);
+ txq->bd.cur = bdp;
+
+ /* Trigger transmission start */
+ if (!(fep->quirks & FEC_QUIRK_ERR007885) ||
+ !readl(txq->bd.reg_desc_active) ||
+ !readl(txq->bd.reg_desc_active) ||
+ !readl(txq->bd.reg_desc_active) ||
+ !readl(txq->bd.reg_desc_active))
+ writel(0, txq->bd.reg_desc_active);
+
+ return 0;
+
+err_release:
+ /* TODO: Release all used data descriptors for TSO */
+ return ret;
+}
+
+static netdev_tx_t
+fec_enet_start_xmit(struct sk_buff *skb, struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int entries_free;
+ unsigned short queue;
+ struct fec_enet_priv_tx_q *txq;
+ struct netdev_queue *nq;
+ int ret;
+
+ if (WARN_ON_ONCE(fep->rtnet.enabled))
+ return -EBUSY;
+
+ queue = skb_get_queue_mapping(skb);
+ txq = fep->tx_queue[queue];
+ nq = netdev_get_tx_queue(ndev, queue);
+
+ if (skb_is_gso(skb))
+ ret = fec_enet_txq_submit_tso(txq, skb, ndev);
+ else
+ ret = fec_enet_txq_submit_skb(txq, skb, ndev);
+ if (ret)
+ return ret;
+
+ entries_free = fec_enet_get_free_txdesc_num(txq);
+ if (entries_free <= txq->tx_stop_threshold)
+ netif_tx_stop_queue(nq);
+
+ return NETDEV_TX_OK;
+}
+
+static netdev_tx_t
+fec_rt_start_xmit(struct rtskb *skb, struct rtnet_device *rtdev)
+{
+ struct fec_enet_priv_tx_q *txq;
+ struct fec_enet_private *fep;
+
+ fep = container_of(rtdev, struct fec_enet_private, rtnet.dev);
+ txq = fep->tx_queue[0];
+
+ return fec_rt_txq_submit_skb(txq, skb, fep->netdev);
+}
+
+static struct net_device_stats *fec_rt_stats(struct rtnet_device *rtdev)
+{
+ struct fec_enet_private *fep;
+
+ fep = container_of(rtdev, struct fec_enet_private, rtnet.dev);
+
+ return &fep->netdev->stats;
+}
+
+/* Init RX & TX buffer descriptors
+ */
+static void fec_enet_bd_init(struct net_device *dev)
+{
+ struct fec_enet_private *fep = netdev_priv(dev);
+ struct fec_enet_priv_tx_q *txq;
+ struct fec_enet_priv_rx_q *rxq;
+ struct bufdesc *bdp;
+ unsigned int i;
+ unsigned int q;
+
+ for (q = 0; q < fep->num_rx_queues; q++) {
+ /* Initialize the receive buffer descriptors. */
+ rxq = fep->rx_queue[q];
+ bdp = rxq->bd.base;
+
+ for (i = 0; i < rxq->bd.ring_size; i++) {
+
+ /* Initialize the BD for every fragment in the page. */
+ if (bdp->cbd_bufaddr)
+ bdp->cbd_sc = cpu_to_fec16(BD_ENET_RX_EMPTY);
+ else
+ bdp->cbd_sc = cpu_to_fec16(0);
+ bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
+ }
+
+ /* Set the last buffer to wrap */
+ bdp = fec_enet_get_prevdesc(bdp, &rxq->bd);
+ bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
+
+ rxq->bd.cur = rxq->bd.base;
+ }
+
+ for (q = 0; q < fep->num_tx_queues; q++) {
+ /* ...and the same for transmit */
+ txq = fep->tx_queue[q];
+ bdp = txq->bd.base;
+ txq->bd.cur = bdp;
+
+ for (i = 0; i < txq->bd.ring_size; i++) {
+ if (txq->tx_skbuff[i]) {
+ if (fep->rtnet.enabled)
+ dev_kfree_rtskb(txq->tx_rtbuff[i]);
+ else
+ dev_kfree_skb_any(txq->tx_skbuff[i]);
+ txq->tx_skbuff[i] = NULL;
+ }
+ /* Initialize the BD for every fragment in the page. */
+ bdp->cbd_sc = cpu_to_fec16(0);
+ if (bdp->cbd_bufaddr &&
+ !IS_TSO_HEADER(txq, fec32_to_cpu(bdp->cbd_bufaddr)))
+ dma_unmap_single(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ fec16_to_cpu(bdp->cbd_datlen),
+ DMA_TO_DEVICE);
+ bdp->cbd_bufaddr = cpu_to_fec32(0);
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+ }
+
+ /* Set the last buffer to wrap */
+ bdp = fec_enet_get_prevdesc(bdp, &txq->bd);
+ bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
+ txq->dirty_tx = bdp;
+ }
+}
+
+static void fec_enet_active_rxring(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int i;
+
+ for (i = 0; i < fep->num_rx_queues; i++)
+ writel(0, fep->rx_queue[i]->bd.reg_desc_active);
+}
+
+static void fec_enet_enable_ring(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_enet_priv_tx_q *txq;
+ struct fec_enet_priv_rx_q *rxq;
+ int i;
+
+ for (i = 0; i < fep->num_rx_queues; i++) {
+ rxq = fep->rx_queue[i];
+ writel(rxq->bd.dma, fep->hwp + FEC_R_DES_START(i));
+ writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_R_BUFF_SIZE(i));
+
+ /* enable DMA1/2 */
+ if (i)
+ writel(RCMR_MATCHEN | RCMR_CMP(i),
+ fep->hwp + FEC_RCMR(i));
+ }
+
+ for (i = 0; i < fep->num_tx_queues; i++) {
+ txq = fep->tx_queue[i];
+ writel(txq->bd.dma, fep->hwp + FEC_X_DES_START(i));
+
+ /* enable DMA1/2 */
+ if (i)
+ writel(DMA_CLASS_EN | IDLE_SLOPE(i),
+ fep->hwp + FEC_DMA_CFG(i));
+ }
+}
+
+static void fec_enet_reset_skb(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_enet_priv_tx_q *txq;
+ int i, j;
+
+ for (i = 0; i < fep->num_tx_queues; i++) {
+ txq = fep->tx_queue[i];
+
+ for (j = 0; j < txq->bd.ring_size; j++) {
+ if (txq->tx_skbuff[j]) {
+ if (fep->rtnet.enabled)
+ dev_kfree_rtskb(txq->tx_rtbuff[i]);
+ else
+ dev_kfree_skb_any(txq->tx_skbuff[j]);
+ txq->tx_skbuff[j] = NULL;
+ }
+ }
+ }
+}
+
+/*
+ * This function is called to start or restart the FEC during a link
+ * change, transmit timeout, or to reconfigure the FEC. The network
+ * packet processing for this device must be stopped before this call.
+ */
+static void
+fec_restart(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ u32 val;
+ u32 temp_mac[2];
+ u32 rcntl = OPT_FRAME_SIZE | 0x04;
+ u32 ecntl = 0x2; /* ETHEREN */
+
+ /* Whack a reset. We should wait for this.
+ * For i.MX6SX SOC, enet use AXI bus, we use disable MAC
+ * instead of reset MAC itself.
+ */
+ if (fep->quirks & FEC_QUIRK_HAS_AVB) {
+ writel(0, fep->hwp + FEC_ECNTRL);
+ } else {
+ writel(1, fep->hwp + FEC_ECNTRL);
+ udelay(10);
+ }
+
+ /*
+ * enet-mac reset will reset mac address registers too,
+ * so need to reconfigure it.
+ */
+ memcpy(&temp_mac, ndev->dev_addr, ETH_ALEN);
+ writel((__force u32)cpu_to_be32(temp_mac[0]),
+ fep->hwp + FEC_ADDR_LOW);
+ writel((__force u32)cpu_to_be32(temp_mac[1]),
+ fep->hwp + FEC_ADDR_HIGH);
+
+ /* Clear any outstanding interrupt. */
+ writel(0xffffffff, fep->hwp + FEC_IEVENT);
+
+ fec_enet_bd_init(ndev);
+
+ fec_enet_enable_ring(ndev);
+
+ /* Reset tx SKB buffers. */
+ fec_enet_reset_skb(ndev);
+
+ /* Enable MII mode */
+ if (fep->full_duplex == DUPLEX_FULL) {
+ /* FD enable */
+ writel(0x04, fep->hwp + FEC_X_CNTRL);
+ } else {
+ /* No Rcv on Xmit */
+ rcntl |= 0x02;
+ writel(0x0, fep->hwp + FEC_X_CNTRL);
+ }
+
+ /* Set MII speed */
+ writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
+
+#if !defined(CONFIG_M5272)
+ if (fep->quirks & FEC_QUIRK_HAS_RACC) {
+ val = readl(fep->hwp + FEC_RACC);
+ /* align IP header */
+ val |= FEC_RACC_SHIFT16;
+ if (fep->csum_flags & FLAG_RX_CSUM_ENABLED)
+ /* set RX checksum */
+ val |= FEC_RACC_OPTIONS;
+ else
+ val &= ~FEC_RACC_OPTIONS;
+ writel(val, fep->hwp + FEC_RACC);
+ writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_FTRL);
+ }
+#endif
+
+ /*
+ * The phy interface and speed need to get configured
+ * differently on enet-mac.
+ */
+ if (fep->quirks & FEC_QUIRK_ENET_MAC) {
+ /* Enable flow control and length check */
+ rcntl |= 0x40000000 | 0x00000020;
+
+ /* RGMII, RMII or MII */
+ if (fep->phy_interface == PHY_INTERFACE_MODE_RGMII ||
+ fep->phy_interface == PHY_INTERFACE_MODE_RGMII_ID ||
+ fep->phy_interface == PHY_INTERFACE_MODE_RGMII_RXID ||
+ fep->phy_interface == PHY_INTERFACE_MODE_RGMII_TXID)
+ rcntl |= (1 << 6);
+ else if (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
+ rcntl |= (1 << 8);
+ else
+ rcntl &= ~(1 << 8);
+
+ /* 1G, 100M or 10M */
+ if (ndev->phydev) {
+ if (ndev->phydev->speed == SPEED_1000)
+ ecntl |= (1 << 5);
+ else if (ndev->phydev->speed == SPEED_100)
+ rcntl &= ~(1 << 9);
+ else
+ rcntl |= (1 << 9);
+ }
+ } else {
+#ifdef FEC_MIIGSK_ENR
+ if (fep->quirks & FEC_QUIRK_USE_GASKET) {
+ u32 cfgr;
+ /* disable the gasket and wait */
+ writel(0, fep->hwp + FEC_MIIGSK_ENR);
+ while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
+ udelay(1);
+
+ /*
+ * configure the gasket:
+ * RMII, 50 MHz, no loopback, no echo
+ * MII, 25 MHz, no loopback, no echo
+ */
+ cfgr = (fep->phy_interface == PHY_INTERFACE_MODE_RMII)
+ ? BM_MIIGSK_CFGR_RMII : BM_MIIGSK_CFGR_MII;
+ if (ndev->phydev && ndev->phydev->speed == SPEED_10)
+ cfgr |= BM_MIIGSK_CFGR_FRCONT_10M;
+ writel(cfgr, fep->hwp + FEC_MIIGSK_CFGR);
+
+ /* re-enable the gasket */
+ writel(2, fep->hwp + FEC_MIIGSK_ENR);
+ }
+#endif
+ }
+
+#if !defined(CONFIG_M5272)
+ /* enable pause frame*/
+ if ((fep->pause_flag & FEC_PAUSE_FLAG_ENABLE) ||
+ ((fep->pause_flag & FEC_PAUSE_FLAG_AUTONEG) &&
+ ndev->phydev && ndev->phydev->pause)) {
+ rcntl |= FEC_ENET_FCE;
+
+ /* set FIFO threshold parameter to reduce overrun */
+ writel(FEC_ENET_RSEM_V, fep->hwp + FEC_R_FIFO_RSEM);
+ writel(FEC_ENET_RSFL_V, fep->hwp + FEC_R_FIFO_RSFL);
+ writel(FEC_ENET_RAEM_V, fep->hwp + FEC_R_FIFO_RAEM);
+ writel(FEC_ENET_RAFL_V, fep->hwp + FEC_R_FIFO_RAFL);
+
+ /* OPD */
+ writel(FEC_ENET_OPD_V, fep->hwp + FEC_OPD);
+ } else {
+ rcntl &= ~FEC_ENET_FCE;
+ }
+#endif /* !defined(CONFIG_M5272) */
+
+ writel(rcntl, fep->hwp + FEC_R_CNTRL);
+
+ /* Setup multicast filter. */
+ set_multicast_list(ndev);
+#ifndef CONFIG_M5272
+ writel(0, fep->hwp + FEC_HASH_TABLE_HIGH);
+ writel(0, fep->hwp + FEC_HASH_TABLE_LOW);
+#endif
+
+ if (fep->quirks & FEC_QUIRK_ENET_MAC) {
+ /* enable ENET endian swap */
+ ecntl |= (1 << 8);
+ /* enable ENET store and forward mode */
+ writel(1 << 8, fep->hwp + FEC_X_WMRK);
+ }
+
+ if (fep->bufdesc_ex)
+ ecntl |= (1 << 4);
+
+#ifndef CONFIG_M5272
+ /* Enable the MIB statistic event counters */
+ writel(0 << 31, fep->hwp + FEC_MIB_CTRLSTAT);
+#endif
+
+ /* And last, enable the transmit and receive processing */
+ writel(ecntl, fep->hwp + FEC_ECNTRL);
+ fec_enet_active_rxring(ndev);
+
+ if (fep->bufdesc_ex)
+ fec_ptp_start_cyclecounter(ndev);
+
+ /* Enable interrupts we wish to service */
+ if (fep->link)
+ writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
+ else
+ writel(FEC_ENET_MII, fep->hwp + FEC_IMASK);
+
+ /* Init the interrupt coalescing */
+ fec_enet_itr_coal_init(ndev);
+
+}
+
+static void
+fec_stop(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
+ u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8);
+ u32 val;
+
+ /* We cannot expect a graceful transmit stop without link !!! */
+ if (fep->link) {
+ writel(1, fep->hwp + FEC_X_CNTRL); /* Graceful transmit stop */
+ udelay(10);
+ if (!(readl(fep->hwp + FEC_IEVENT) & FEC_ENET_GRA))
+ netdev_err(ndev, "Graceful transmit stop did not complete!\n");
+ }
+
+ /* Whack a reset. We should wait for this.
+ * For i.MX6SX SOC, enet use AXI bus, we use disable MAC
+ * instead of reset MAC itself.
+ */
+ if (!(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) {
+ if (fep->quirks & FEC_QUIRK_HAS_AVB) {
+ writel(0, fep->hwp + FEC_ECNTRL);
+ } else {
+ writel(1, fep->hwp + FEC_ECNTRL);
+ udelay(10);
+ }
+ writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
+ } else {
+ writel(FEC_DEFAULT_IMASK | FEC_ENET_WAKEUP, fep->hwp + FEC_IMASK);
+ val = readl(fep->hwp + FEC_ECNTRL);
+ val |= (FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
+ writel(val, fep->hwp + FEC_ECNTRL);
+
+ if (pdata && pdata->sleep_mode_enable)
+ pdata->sleep_mode_enable(true);
+ }
+ writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
+
+ /* We have to keep ENET enabled to have MII interrupt stay working */
+ if (fep->quirks & FEC_QUIRK_ENET_MAC &&
+ !(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) {
+ writel(2, fep->hwp + FEC_ECNTRL);
+ writel(rmii_mode, fep->hwp + FEC_R_CNTRL);
+ }
+}
+
+
+static void
+fec_timeout(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ fec_dump(ndev);
+
+ ndev->stats.tx_errors++;
+
+ schedule_work(&fep->tx_timeout_work);
+}
+
+static void fec_enet_timeout_work(struct work_struct *work)
+{
+ struct fec_enet_private *fep =
+ container_of(work, struct fec_enet_private, tx_timeout_work);
+ struct net_device *ndev = fep->netdev;
+
+ rtnl_lock();
+ if (netif_device_present(ndev) || netif_running(ndev)) {
+ if_lock(ndev);
+ fec_restart(ndev);
+ if_wake_unlock(ndev, false);
+ }
+ rtnl_unlock();
+}
+
+static void
+fec_enet_hwtstamp(struct fec_enet_private *fep, unsigned ts,
+ struct skb_shared_hwtstamps *hwtstamps)
+{
+ unsigned long flags;
+ u64 ns;
+
+ spin_lock_irqsave(&fep->tmreg_lock, flags);
+ ns = timecounter_cyc2time(&fep->tc, ts);
+ spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+
+ memset(hwtstamps, 0, sizeof(*hwtstamps));
+ hwtstamps->hwtstamp = ns_to_ktime(ns);
+}
+
+static void
+fec_enet_tx_queue(struct net_device *ndev, u16 queue_id)
+{
+ struct fec_enet_private *fep;
+ struct bufdesc *bdp;
+ unsigned short status;
+ struct sk_buff *skb;
+ struct fec_enet_priv_tx_q *txq;
+ struct netdev_queue *nq;
+ int index = 0;
+ int entries_free;
+
+ fep = netdev_priv(ndev);
+
+ queue_id = FEC_ENET_GET_QUQUE(queue_id);
+
+ txq = fep->tx_queue[queue_id];
+ /* get next bdp of dirty_tx */
+ nq = netdev_get_tx_queue(ndev, queue_id);
+ bdp = txq->dirty_tx;
+
+ /* get next bdp of dirty_tx */
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+
+ while (bdp != READ_ONCE(txq->bd.cur)) {
+ /* Order the load of bd.cur and cbd_sc */
+ rmb();
+ status = fec16_to_cpu(READ_ONCE(bdp->cbd_sc));
+ if (status & BD_ENET_TX_READY)
+ break;
+
+ index = fec_enet_get_bd_index(bdp, &txq->bd);
+
+ skb = txq->tx_skbuff[index];
+ txq->tx_skbuff[index] = NULL;
+ if (!IS_TSO_HEADER(txq, fec32_to_cpu(bdp->cbd_bufaddr)))
+ dma_unmap_single(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ fec16_to_cpu(bdp->cbd_datlen),
+ DMA_TO_DEVICE);
+ bdp->cbd_bufaddr = cpu_to_fec32(0);
+ if (!skb)
+ goto skb_done;
+
+ /* Check for errors. */
+ if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
+ BD_ENET_TX_RL | BD_ENET_TX_UN |
+ BD_ENET_TX_CSL)) {
+ ndev->stats.tx_errors++;
+ if (status & BD_ENET_TX_HB) /* No heartbeat */
+ ndev->stats.tx_heartbeat_errors++;
+ if (status & BD_ENET_TX_LC) /* Late collision */
+ ndev->stats.tx_window_errors++;
+ if (status & BD_ENET_TX_RL) /* Retrans limit */
+ ndev->stats.tx_aborted_errors++;
+ if (status & BD_ENET_TX_UN) /* Underrun */
+ ndev->stats.tx_fifo_errors++;
+ if (status & BD_ENET_TX_CSL) /* Carrier lost */
+ ndev->stats.tx_carrier_errors++;
+ } else {
+ ndev->stats.tx_packets++;
+ ndev->stats.tx_bytes += skb->len;
+ }
+
+ if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS) &&
+ fep->bufdesc_ex) {
+ struct skb_shared_hwtstamps shhwtstamps;
+ struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
+
+ fec_enet_hwtstamp(fep, fec32_to_cpu(ebdp->ts), &shhwtstamps);
+ skb_tstamp_tx(skb, &shhwtstamps);
+ }
+
+ /* Deferred means some collisions occurred during transmit,
+ * but we eventually sent the packet OK.
+ */
+ if (status & BD_ENET_TX_DEF)
+ ndev->stats.collisions++;
+
+ /* Free the sk buffer associated with this last transmit */
+ dev_kfree_skb_any(skb);
+skb_done:
+ /* Make sure the update to bdp and tx_skbuff are performed
+ * before dirty_tx
+ */
+ wmb();
+ txq->dirty_tx = bdp;
+
+ /* Update pointer to next buffer descriptor to be transmitted */
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+
+ /* Since we have freed up a buffer, the ring is no longer full
+ */
+ if (netif_queue_stopped(ndev)) {
+ entries_free = fec_enet_get_free_txdesc_num(txq);
+ if (entries_free >= txq->tx_wake_threshold)
+ netif_tx_wake_queue(nq);
+ }
+ }
+
+ /* ERR006358: Keep the transmitter going */
+ if (bdp != txq->bd.cur &&
+ readl(txq->bd.reg_desc_active) == 0)
+ writel(0, txq->bd.reg_desc_active);
+}
+
+static void
+fec_rt_tx_queue(struct net_device *ndev, u16 queue_id)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ struct bufdesc *bdp;
+ unsigned short status;
+ struct rtskb *skb;
+ struct fec_enet_priv_tx_q *txq;
+ int index;
+
+ queue_id = FEC_ENET_GET_QUQUE(queue_id);
+
+ txq = fep->tx_queue[queue_id];
+
+ rtdm_lock_get(&frt->lock);
+
+ /* get next bdp of dirty_tx */
+ bdp = txq->dirty_tx;
+
+ /* get next bdp of dirty_tx */
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+
+ while (bdp != READ_ONCE(txq->bd.cur)) {
+ /* Order the load of bd.cur and cbd_sc */
+ rmb();
+ status = fec16_to_cpu(READ_ONCE(bdp->cbd_sc));
+ if (status & BD_ENET_TX_READY)
+ break;
+
+ index = fec_enet_get_bd_index(bdp, &txq->bd);
+
+ skb = txq->tx_rtbuff[index];
+ txq->tx_rtbuff[index] = NULL;
+ dma_unmap_single(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ fec16_to_cpu(bdp->cbd_datlen),
+ DMA_TO_DEVICE);
+
+ bdp->cbd_bufaddr = cpu_to_fec32(0);
+ if (!skb)
+ goto skb_done;
+
+ /* Check for errors. */
+ if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
+ BD_ENET_TX_RL | BD_ENET_TX_UN |
+ BD_ENET_TX_CSL)) {
+ ndev->stats.tx_errors++;
+ if (status & BD_ENET_TX_HB) /* No heartbeat */
+ ndev->stats.tx_heartbeat_errors++;
+ if (status & BD_ENET_TX_LC) /* Late collision */
+ ndev->stats.tx_window_errors++;
+ if (status & BD_ENET_TX_RL) /* Retrans limit */
+ ndev->stats.tx_aborted_errors++;
+ if (status & BD_ENET_TX_UN) /* Underrun */
+ ndev->stats.tx_fifo_errors++;
+ if (status & BD_ENET_TX_CSL) /* Carrier lost */
+ ndev->stats.tx_carrier_errors++;
+ } else {
+ ndev->stats.tx_packets++;
+ ndev->stats.tx_bytes += skb->len;
+ }
+
+ /* Deferred means some collisions occurred during transmit,
+ * but we eventually sent the packet OK.
+ */
+ if (status & BD_ENET_TX_DEF)
+ ndev->stats.collisions++;
+
+ dev_kfree_rtskb(skb);
+skb_done:
+ /* Make sure the update to bdp and tx_rtbuff are performed
+ * before dirty_tx
+ */
+ wmb();
+ txq->dirty_tx = bdp;
+
+ /* Update pointer to next buffer descriptor to be transmitted */
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+
+ /* Since we have freed up a buffer, the ring is no longer full
+ */
+ if (rtnetif_queue_stopped(&frt->dev))
+ rtnetif_wake_queue(&frt->dev);
+ }
+
+ /* ERR006358: Keep the transmitter going */
+ if (bdp != txq->bd.cur &&
+ readl(txq->bd.reg_desc_active) == 0)
+ writel(0, txq->bd.reg_desc_active);
+
+ rtdm_lock_put(&frt->lock);
+}
+
+static void
+fec_enet_tx(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ u16 queue_id;
+ /* First process class A queue, then Class B and Best Effort queue */
+ for_each_set_bit(queue_id, &fep->work_tx, FEC_ENET_MAX_TX_QS) {
+ clear_bit(queue_id, &fep->work_tx);
+ if (frt->enabled)
+ fec_rt_tx_queue(ndev, queue_id);
+ else
+ fec_enet_tx_queue(ndev, queue_id);
+ }
+ return;
+}
+
+static int
+fec_enet_new_rxbdp(struct net_device *ndev, struct bufdesc *bdp, struct sk_buff *skb)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int off;
+
+ off = ((unsigned long)skb->data) & fep->rx_align;
+ if (off)
+ skb_reserve(skb, fep->rx_align + 1 - off);
+
+ bdp->cbd_bufaddr = cpu_to_fec32(dma_map_single(&fep->pdev->dev, skb->data, FEC_ENET_RX_FRSIZE - fep->rx_align, DMA_FROM_DEVICE));
+ if (dma_mapping_error(&fep->pdev->dev, fec32_to_cpu(bdp->cbd_bufaddr))) {
+ if (net_ratelimit())
+ netdev_err(ndev, "Rx DMA memory map failed\n");
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+static int
+fec_rt_new_rxbdp(struct net_device *ndev, struct bufdesc *bdp, struct rtskb *skb)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int off;
+
+ off = ((unsigned long)skb->data) & fep->rx_align;
+ if (off)
+ rtskb_reserve(skb, fep->rx_align + 1 - off);
+
+ bdp->cbd_bufaddr = cpu_to_fec32(dma_map_single(&fep->pdev->dev, skb->data,
+ RTSKB_SIZE - fep->rx_align,
+ DMA_FROM_DEVICE));
+ if (dma_mapping_error(&fep->pdev->dev, fec32_to_cpu(bdp->cbd_bufaddr))) {
+ rtdm_printk_ratelimited("%s: Rx DMA memory map failed\n",
+ dev_name(&fep->pdev->dev));
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+static bool fec_enet_copybreak(struct net_device *ndev, struct sk_buff **skb,
+ struct bufdesc *bdp, u32 length, bool swap)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ struct sk_buff *new_skb;
+
+ if (length > fep->rx_copybreak || frt->enabled)
+ return false;
+
+ new_skb = netdev_alloc_skb(ndev, length);
+ if (!new_skb)
+ return false;
+
+ dma_sync_single_for_cpu(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ FEC_ENET_RX_FRSIZE - fep->rx_align,
+ DMA_FROM_DEVICE);
+ if (!swap)
+ memcpy(new_skb->data, (*skb)->data, length);
+ else
+ swap_buffer2(new_skb->data, (*skb)->data, length);
+ *skb = new_skb;
+
+ return true;
+}
+
+/* During a receive, the bd_rx.cur points to the current incoming buffer.
+ * When we update through the ring, if the next incoming buffer has
+ * not been given to the system, we just set the empty indicator,
+ * effectively tossing the packet.
+ */
+static int
+fec_enet_rx_queue(struct net_device *ndev, int budget, u16 queue_id)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_enet_priv_rx_q *rxq;
+ struct bufdesc *bdp;
+ unsigned short status;
+ struct sk_buff *skb_new = NULL;
+ struct sk_buff *skb;
+ ushort pkt_len;
+ __u8 *data;
+ int pkt_received = 0;
+ struct bufdesc_ex *ebdp = NULL;
+ bool vlan_packet_rcvd = false;
+ u16 vlan_tag;
+ int index = 0;
+ bool is_copybreak;
+ bool need_swap = fep->quirks & FEC_QUIRK_SWAP_FRAME;
+
+#ifdef CONFIG_M532x
+ flush_cache_all();
+#endif
+ queue_id = FEC_ENET_GET_QUQUE(queue_id);
+ rxq = fep->rx_queue[queue_id];
+
+ /* First, grab all of the stats for the incoming packet.
+ * These get messed up if we get called due to a busy condition.
+ */
+ bdp = rxq->bd.cur;
+
+ while (!((status = fec16_to_cpu(bdp->cbd_sc)) & BD_ENET_RX_EMPTY)) {
+
+ if (pkt_received >= budget)
+ break;
+ pkt_received++;
+
+ writel(FEC_ENET_RXF, fep->hwp + FEC_IEVENT);
+
+ /* Check for errors. */
+ status ^= BD_ENET_RX_LAST;
+ if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
+ BD_ENET_RX_CR | BD_ENET_RX_OV | BD_ENET_RX_LAST |
+ BD_ENET_RX_CL)) {
+ ndev->stats.rx_errors++;
+ if (status & BD_ENET_RX_OV) {
+ /* FIFO overrun */
+ ndev->stats.rx_fifo_errors++;
+ goto rx_processing_done;
+ }
+ if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH
+ | BD_ENET_RX_LAST)) {
+ /* Frame too long or too short. */
+ ndev->stats.rx_length_errors++;
+ if (status & BD_ENET_RX_LAST)
+ netdev_err(ndev, "rcv is not +last\n");
+ }
+ if (status & BD_ENET_RX_CR) /* CRC Error */
+ ndev->stats.rx_crc_errors++;
+ /* Report late collisions as a frame error. */
+ if (status & (BD_ENET_RX_NO | BD_ENET_RX_CL))
+ ndev->stats.rx_frame_errors++;
+ goto rx_processing_done;
+ }
+
+ /* Process the incoming frame. */
+ ndev->stats.rx_packets++;
+ pkt_len = fec16_to_cpu(bdp->cbd_datlen);
+ ndev->stats.rx_bytes += pkt_len;
+
+ index = fec_enet_get_bd_index(bdp, &rxq->bd);
+ skb = rxq->rx_skbuff[index];
+
+ /* The packet length includes FCS, but we don't want to
+ * include that when passing upstream as it messes up
+ * bridging applications.
+ */
+ is_copybreak = fec_enet_copybreak(ndev, &skb, bdp, pkt_len - 4,
+ need_swap);
+ if (!is_copybreak) {
+ skb_new = netdev_alloc_skb(ndev, FEC_ENET_RX_FRSIZE);
+ if (unlikely(!skb_new)) {
+ ndev->stats.rx_dropped++;
+ goto rx_processing_done;
+ }
+ dma_unmap_single(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ FEC_ENET_RX_FRSIZE - fep->rx_align,
+ DMA_FROM_DEVICE);
+ }
+
+ prefetch(skb->data - NET_IP_ALIGN);
+ skb_put(skb, pkt_len - 4);
+ data = skb->data;
+
+ if (!is_copybreak && need_swap)
+ swap_buffer(data, pkt_len);
+
+#if !defined(CONFIG_M5272)
+ if (fep->quirks & FEC_QUIRK_HAS_RACC)
+ data = skb_pull_inline(skb, 2);
+#endif
+
+ /* Extract the enhanced buffer descriptor */
+ ebdp = NULL;
+ if (fep->bufdesc_ex)
+ ebdp = (struct bufdesc_ex *)bdp;
+
+ /* If this is a VLAN packet remove the VLAN Tag */
+ vlan_packet_rcvd = false;
+ if ((ndev->features & NETIF_F_HW_VLAN_CTAG_RX) &&
+ fep->bufdesc_ex &&
+ (ebdp->cbd_esc & cpu_to_fec32(BD_ENET_RX_VLAN))) {
+ /* Push and remove the vlan tag */
+ struct vlan_hdr *vlan_header =
+ (struct vlan_hdr *) (data + ETH_HLEN);
+ vlan_tag = ntohs(vlan_header->h_vlan_TCI);
+
+ vlan_packet_rcvd = true;
+
+ memmove(skb->data + VLAN_HLEN, data, ETH_ALEN * 2);
+ skb_pull(skb, VLAN_HLEN);
+ }
+
+ skb->protocol = eth_type_trans(skb, ndev);
+
+ /* Get receive timestamp from the skb */
+ if (fep->hwts_rx_en && fep->bufdesc_ex)
+ fec_enet_hwtstamp(fep, fec32_to_cpu(ebdp->ts),
+ skb_hwtstamps(skb));
+
+ if (fep->bufdesc_ex &&
+ (fep->csum_flags & FLAG_RX_CSUM_ENABLED)) {
+ if (!(ebdp->cbd_esc & cpu_to_fec32(FLAG_RX_CSUM_ERROR))) {
+ /* don't check it */
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+ } else {
+ skb_checksum_none_assert(skb);
+ }
+ }
+
+ /* Handle received VLAN packets */
+ if (vlan_packet_rcvd)
+ __vlan_hwaccel_put_tag(skb,
+ htons(ETH_P_8021Q),
+ vlan_tag);
+
+ napi_gro_receive(&fep->napi, skb);
+
+ if (is_copybreak) {
+ dma_sync_single_for_device(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ FEC_ENET_RX_FRSIZE - fep->rx_align,
+ DMA_FROM_DEVICE);
+ } else {
+ rxq->rx_skbuff[index] = skb_new;
+ fec_enet_new_rxbdp(ndev, bdp, skb_new);
+ }
+
+rx_processing_done:
+ /* Clear the status flags for this buffer */
+ status &= ~BD_ENET_RX_STATS;
+
+ /* Mark the buffer empty */
+ status |= BD_ENET_RX_EMPTY;
+
+ if (fep->bufdesc_ex) {
+ struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
+
+ ebdp->cbd_esc = cpu_to_fec32(BD_ENET_RX_INT);
+ ebdp->cbd_prot = 0;
+ ebdp->cbd_bdu = 0;
+ }
+ /* Make sure the updates to rest of the descriptor are
+ * performed before transferring ownership.
+ */
+ wmb();
+ bdp->cbd_sc = cpu_to_fec16(status);
+
+ /* Update BD pointer to next entry */
+ bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
+
+ /* Doing this here will keep the FEC running while we process
+ * incoming frames. On a heavily loaded network, we should be
+ * able to keep up at the expense of system resources.
+ */
+ writel(0, rxq->bd.reg_desc_active);
+ }
+ rxq->bd.cur = bdp;
+ return pkt_received;
+}
+
+static int
+fec_rt_rx_queue(struct net_device *ndev, int budget, u16 queue_id)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ struct fec_enet_priv_rx_q *rxq;
+ struct bufdesc *bdp;
+ unsigned short status;
+ struct rtskb *skb_new, *skb;
+ ushort pkt_len;
+ __u8 *data;
+ int pkt_received = 0;
+ struct bufdesc_ex *ebdp = NULL;
+ int index;
+ bool need_swap = fep->quirks & FEC_QUIRK_SWAP_FRAME;
+
+#ifdef CONFIG_M532x
+ flush_cache_all();
+#endif
+ queue_id = FEC_ENET_GET_QUQUE(queue_id);
+ rxq = fep->rx_queue[queue_id];
+
+ rtdm_lock_get(&frt->lock);
+
+ /* First, grab all of the stats for the incoming packet.
+ * These get messed up if we get called due to a busy condition.
+ */
+ bdp = rxq->bd.cur;
+
+ while (!((status = fec16_to_cpu(bdp->cbd_sc)) & BD_ENET_RX_EMPTY)) {
+
+ if (pkt_received >= budget)
+ break;
+ pkt_received++;
+
+ writel(FEC_ENET_RXF, fep->hwp + FEC_IEVENT);
+
+ /* Check for errors. */
+ status ^= BD_ENET_RX_LAST;
+ if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
+ BD_ENET_RX_CR | BD_ENET_RX_OV | BD_ENET_RX_LAST |
+ BD_ENET_RX_CL)) {
+ ndev->stats.rx_errors++;
+ if (status & BD_ENET_RX_OV) {
+ /* FIFO overrun */
+ ndev->stats.rx_fifo_errors++;
+ goto rx_processing_done;
+ }
+ if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH
+ | BD_ENET_RX_LAST)) {
+ /* Frame too long or too short. */
+ ndev->stats.rx_length_errors++;
+ if (status & BD_ENET_RX_LAST)
+ netdev_err(ndev, "rcv is not +last\n");
+ }
+ if (status & BD_ENET_RX_CR) /* CRC Error */
+ ndev->stats.rx_crc_errors++;
+ /* Report late collisions as a frame error. */
+ if (status & (BD_ENET_RX_NO | BD_ENET_RX_CL))
+ ndev->stats.rx_frame_errors++;
+ goto rx_processing_done;
+ }
+
+ /* Process the incoming frame. */
+ ndev->stats.rx_packets++;
+ pkt_len = fec16_to_cpu(bdp->cbd_datlen);
+ ndev->stats.rx_bytes += pkt_len;
+
+ index = fec_enet_get_bd_index(bdp, &rxq->bd);
+ skb = rxq->rx_rtbuff[index];
+ if (skb == NULL)
+ goto rx_processing_done;
+
+ dma_unmap_single(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ RTSKB_SIZE - fep->rx_align,
+ DMA_FROM_DEVICE);
+
+ prefetch(skb->data - NET_IP_ALIGN);
+ rtskb_put(skb, pkt_len - 4);
+ data = skb->data;
+
+ if (need_swap)
+ swap_buffer(data, pkt_len);
+
+#if !defined(CONFIG_M5272)
+ if (fep->quirks & FEC_QUIRK_HAS_RACC)
+ data = rtskb_pull(skb, 2);
+#endif
+
+ skb->protocol = rt_eth_type_trans(skb, &frt->dev);
+
+ /* Extract the enhanced buffer descriptor */
+ if (fep->bufdesc_ex) {
+ ebdp = (struct bufdesc_ex *)bdp;
+ if (fep->csum_flags & FLAG_RX_CSUM_ENABLED) {
+ if (!(ebdp->cbd_esc & cpu_to_fec32(FLAG_RX_CSUM_ERROR)))
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+ else
+ WARN_ON_ONCE(skb->ip_summed != CHECKSUM_NONE);
+ }
+ }
+
+ skb_new = rtnetdev_alloc_rtskb(&frt->dev, RTSKB_SIZE);
+ if (unlikely(skb_new == NULL))
+ ndev->stats.rx_dropped++;
+ else {
+ rtnetif_rx(skb);
+ rxq->rx_rtbuff[index] = skb_new;
+ fec_rt_new_rxbdp(ndev, bdp, skb_new);
+ }
+
+rx_processing_done:
+ /* Clear the status flags for this buffer */
+ status &= ~BD_ENET_RX_STATS;
+
+ /* Mark the buffer empty */
+ status |= BD_ENET_RX_EMPTY;
+
+ if (fep->bufdesc_ex) {
+ ebdp = (struct bufdesc_ex *)bdp;
+ ebdp->cbd_esc = cpu_to_fec32(BD_ENET_RX_INT);
+ ebdp->cbd_prot = 0;
+ ebdp->cbd_bdu = 0;
+ }
+ /* Make sure the updates to rest of the descriptor are
+ * performed before transferring ownership.
+ */
+ wmb();
+ bdp->cbd_sc = cpu_to_fec16(status);
+
+ /* Update BD pointer to next entry */
+ bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
+
+ /* Doing this here will keep the FEC running while we process
+ * incoming frames. On a heavily loaded network, we should be
+ * able to keep up at the expense of system resources.
+ */
+ writel(0, rxq->bd.reg_desc_active);
+ }
+ rxq->bd.cur = bdp;
+
+ rtdm_lock_put(&frt->lock);
+
+ if (pkt_received)
+ rt_mark_stack_mgr(&frt->dev);
+
+ return pkt_received;
+}
+
+static int
+fec_enet_rx(struct net_device *ndev, int budget)
+{
+ int pkt_received = 0, ret;
+ u16 queue_id;
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ for_each_set_bit(queue_id, &fep->work_rx, FEC_ENET_MAX_RX_QS) {
+ if (frt->enabled)
+ ret = fec_rt_rx_queue(ndev,
+ budget - pkt_received, queue_id);
+ else
+ ret = fec_enet_rx_queue(ndev,
+ budget - pkt_received, queue_id);
+
+ if (ret < budget - pkt_received)
+ clear_bit(queue_id, &fep->work_rx);
+
+ pkt_received += ret;
+ }
+ return pkt_received;
+}
+
+static bool
+fec_enet_collect_events(struct fec_enet_private *fep, uint int_events)
+{
+ if (int_events == 0)
+ return false;
+
+ if (int_events & FEC_ENET_RXF_0)
+ fep->work_rx |= (1 << 2);
+ if (int_events & FEC_ENET_RXF_1)
+ fep->work_rx |= (1 << 0);
+ if (int_events & FEC_ENET_RXF_2)
+ fep->work_rx |= (1 << 1);
+
+ if (int_events & FEC_ENET_TXF_0)
+ fep->work_tx |= (1 << 2);
+ if (int_events & FEC_ENET_TXF_1)
+ fep->work_tx |= (1 << 0);
+ if (int_events & FEC_ENET_TXF_2)
+ fep->work_tx |= (1 << 1);
+
+ return true;
+}
+
+static void fec_enet_mdio_done(rtdm_nrtsig_t *nrt_sig, void *data)
+{
+ struct fec_enet_private *fep = data;
+
+ complete(&fep->mdio_done);
+}
+
+static irqreturn_t
+fec_enet_interrupt(int irq, void *dev_id)
+{
+ struct net_device *ndev = dev_id;
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ uint int_events;
+ irqreturn_t ret = IRQ_NONE;
+
+ int_events = readl(fep->hwp + FEC_IEVENT);
+ writel(int_events, fep->hwp + FEC_IEVENT);
+ fec_enet_collect_events(fep, int_events);
+
+ if ((fep->work_tx || fep->work_rx) && fep->link) {
+ ret = IRQ_HANDLED;
+ if (napi_schedule_prep(&fep->napi)) {
+ /* Disable the NAPI interrupts */
+ writel(FEC_NAPI_IMASK, fep->hwp + FEC_IMASK);
+ __napi_schedule(&fep->napi);
+ }
+ }
+
+ if (int_events & FEC_ENET_MII) {
+ ret = IRQ_HANDLED;
+ complete(&fep->mdio_done);
+ }
+
+ if (fep->ptp_clock)
+ if (fec_ptp_check_pps_event(fep))
+ ret = IRQ_HANDLED;
+ return ret;
+}
+
+static int fec_rt_interrupt(rtdm_irq_t *irqh)
+{
+ struct net_device *ndev = rtdm_irq_get_arg(irqh, struct net_device);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ irqreturn_t ret = RTDM_IRQ_NONE;
+ uint int_events;
+
+ int_events = readl(fep->hwp + FEC_IEVENT);
+ writel(int_events, fep->hwp + FEC_IEVENT);
+ fec_enet_collect_events(fep, int_events);
+
+ if ((fep->work_tx || fep->work_rx) && fep->link) {
+ if (fep->work_rx)
+ fec_enet_rx(ndev, RX_RING_SIZE);
+ if (fep->work_tx)
+ fec_enet_tx(ndev);
+ ret = RTDM_IRQ_HANDLED;
+ }
+
+ if (int_events & FEC_ENET_MII) {
+ rtdm_nrtsig_pend(&fep->rtnet.mdio_sig);
+ ret = RTDM_IRQ_HANDLED;
+ }
+
+ return ret;
+}
+
+static int fec_enet_rx_napi(struct napi_struct *napi, int budget)
+{
+ struct net_device *ndev = napi->dev;
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int pkts;
+
+ pkts = fec_enet_rx(ndev, budget);
+
+ fec_enet_tx(ndev);
+
+ if (pkts < budget) {
+ napi_complete_done(napi, pkts);
+ writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
+ }
+ return pkts;
+}
+
+/* ------------------------------------------------------------------------- */
+static void fec_get_mac(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_platform_data *pdata = dev_get_platdata(&fep->pdev->dev);
+ unsigned char *iap, tmpaddr[ETH_ALEN];
+
+ /*
+ * try to get mac address in following order:
+ *
+ * 1) module parameter via kernel command line in form
+ * fec.macaddr=0x00,0x04,0x9f,0x01,0x30,0xe0
+ */
+ iap = macaddr;
+
+ /*
+ * 2) from device tree data
+ */
+ if (!is_valid_ether_addr(iap)) {
+ struct device_node *np = fep->pdev->dev.of_node;
+ if (np) {
+ const char *mac = of_get_mac_address(np);
+ if (mac)
+ iap = (unsigned char *) mac;
+ }
+ }
+
+ /*
+ * 3) from flash or fuse (via platform data)
+ */
+ if (!is_valid_ether_addr(iap)) {
+#ifdef CONFIG_M5272
+ if (FEC_FLASHMAC)
+ iap = (unsigned char *)FEC_FLASHMAC;
+#else
+ if (pdata)
+ iap = (unsigned char *)&pdata->mac;
+#endif
+ }
+
+ /*
+ * 4) FEC mac registers set by bootloader
+ */
+ if (!is_valid_ether_addr(iap)) {
+ *((__be32 *) &tmpaddr[0]) =
+ cpu_to_be32(readl(fep->hwp + FEC_ADDR_LOW));
+ *((__be16 *) &tmpaddr[4]) =
+ cpu_to_be16(readl(fep->hwp + FEC_ADDR_HIGH) >> 16);
+ iap = &tmpaddr[0];
+ }
+
+ /*
+ * 5) random mac address
+ */
+ if (!is_valid_ether_addr(iap)) {
+ /* Report it and use a random ethernet address instead */
+ netdev_err(ndev, "Invalid MAC address: %pM\n", iap);
+ eth_hw_addr_random(ndev);
+ netdev_info(ndev, "Using random MAC address: %pM\n",
+ ndev->dev_addr);
+ return;
+ }
+
+ memcpy(ndev->dev_addr, iap, ETH_ALEN);
+
+ /* Adjust MAC if using macaddr */
+ if (iap == macaddr)
+ ndev->dev_addr[ETH_ALEN-1] = macaddr[ETH_ALEN-1] + fep->dev_id;
+}
+
+/* ------------------------------------------------------------------------- */
+
+/*
+ * Phy section
+ */
+static void do_adjust_link(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct phy_device *phy_dev = ndev->phydev;
+ int status_change = 0;
+
+ /* Prevent a state halted on mii error */
+ if (fep->mii_timeout && phy_dev->state == PHY_HALTED) {
+ phy_dev->state = PHY_RESUMING;
+ return;
+ }
+
+ /*
+ * If the netdev is down, or is going down, we're not interested
+ * in link state events, so just mark our idea of the link as down
+ * and ignore the event.
+ */
+ if (!if_running(ndev) || !netif_device_present(ndev))
+ fep->link = 0;
+ else if (phy_dev->link) {
+ if (!fep->link) {
+ fep->link = phy_dev->link;
+ status_change = 1;
+ }
+
+ if (fep->full_duplex != phy_dev->duplex) {
+ fep->full_duplex = phy_dev->duplex;
+ status_change = 1;
+ }
+
+ if (phy_dev->speed != fep->speed) {
+ fep->speed = phy_dev->speed;
+ status_change = 1;
+ }
+
+ /* if any of the above changed restart the FEC. */
+ if (status_change) {
+ if_lock(ndev);
+ fec_restart(ndev);
+ if_wake_unlock(ndev, false);
+ }
+ } else {
+ if (fep->link) {
+ if_lock(ndev);
+ fec_stop(ndev);
+ if_unlock(ndev);
+ fep->link = phy_dev->link;
+ status_change = 1;
+ }
+ }
+
+ if (status_change)
+ phy_print_status(phy_dev);
+}
+
+static void fec_enet_adjust_link(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ do_adjust_link(ndev);
+
+ /*
+ * PHYLIB sets netif_carrier_on() when the link is up,
+ * propagate state change to RTnet.
+ */
+ if (fep->rtnet.enabled) {
+ if (netif_carrier_ok(ndev)) {
+ netdev_info(ndev, "carrier detected\n");
+ rtnetif_carrier_on(&fep->rtnet.dev);
+ } else {
+ netdev_info(ndev, "carrier lost\n");
+ rtnetif_carrier_off(&fep->rtnet.dev);
+ }
+ }
+}
+
+static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+ struct fec_enet_private *fep = bus->priv;
+ struct device *dev = &fep->pdev->dev;
+ unsigned long time_left;
+ int ret = 0;
+
+ ret = pm_runtime_get_sync(dev);
+ if (ret < 0)
+ return ret;
+
+ fep->mii_timeout = 0;
+ reinit_completion(&fep->mdio_done);
+
+ /* start a read op */
+ writel(FEC_MMFR_ST | FEC_MMFR_OP_READ |
+ FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
+ FEC_MMFR_TA, fep->hwp + FEC_MII_DATA);
+
+ /* wait for end of transfer */
+ time_left = wait_for_completion_timeout(&fep->mdio_done,
+ usecs_to_jiffies(FEC_MII_TIMEOUT));
+ if (time_left == 0) {
+ fep->mii_timeout = 1;
+ netdev_err(fep->netdev, "MDIO read timeout\n");
+ ret = -ETIMEDOUT;
+ goto out;
+ }
+
+ ret = FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
+
+out:
+ pm_runtime_mark_last_busy(dev);
+ pm_runtime_put_autosuspend(dev);
+
+ return ret;
+}
+
+static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
+ u16 value)
+{
+ struct fec_enet_private *fep = bus->priv;
+ struct device *dev = &fep->pdev->dev;
+ unsigned long time_left;
+ int ret;
+
+ ret = pm_runtime_get_sync(dev);
+ if (ret < 0)
+ return ret;
+ else
+ ret = 0;
+
+ fep->mii_timeout = 0;
+ reinit_completion(&fep->mdio_done);
+
+ /* start a write op */
+ writel(FEC_MMFR_ST | FEC_MMFR_OP_WRITE |
+ FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
+ FEC_MMFR_TA | FEC_MMFR_DATA(value),
+ fep->hwp + FEC_MII_DATA);
+
+ /* wait for end of transfer */
+ time_left = wait_for_completion_timeout(&fep->mdio_done,
+ usecs_to_jiffies(FEC_MII_TIMEOUT));
+ if (time_left == 0) {
+ fep->mii_timeout = 1;
+ netdev_err(fep->netdev, "MDIO write timeout\n");
+ ret = -ETIMEDOUT;
+ }
+
+ pm_runtime_mark_last_busy(dev);
+ pm_runtime_put_autosuspend(dev);
+
+ return ret;
+}
+
+static int fec_enet_clk_enable(struct net_device *ndev, bool enable)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int ret;
+
+ if (enable) {
+ ret = clk_prepare_enable(fep->clk_ahb);
+ if (ret)
+ return ret;
+
+ ret = clk_prepare_enable(fep->clk_enet_out);
+ if (ret)
+ goto failed_clk_enet_out;
+
+ if (fep->clk_ptp) {
+ mutex_lock(&fep->ptp_clk_mutex);
+ ret = clk_prepare_enable(fep->clk_ptp);
+ if (ret) {
+ mutex_unlock(&fep->ptp_clk_mutex);
+ goto failed_clk_ptp;
+ } else {
+ fep->ptp_clk_on = true;
+ }
+ mutex_unlock(&fep->ptp_clk_mutex);
+ }
+
+ ret = clk_prepare_enable(fep->clk_ref);
+ if (ret)
+ goto failed_clk_ref;
+ } else {
+ clk_disable_unprepare(fep->clk_ahb);
+ clk_disable_unprepare(fep->clk_enet_out);
+ if (fep->clk_ptp) {
+ mutex_lock(&fep->ptp_clk_mutex);
+ clk_disable_unprepare(fep->clk_ptp);
+ fep->ptp_clk_on = false;
+ mutex_unlock(&fep->ptp_clk_mutex);
+ }
+ clk_disable_unprepare(fep->clk_ref);
+ }
+
+ return 0;
+
+failed_clk_ref:
+ if (fep->clk_ref)
+ clk_disable_unprepare(fep->clk_ref);
+failed_clk_ptp:
+ if (fep->clk_enet_out)
+ clk_disable_unprepare(fep->clk_enet_out);
+failed_clk_enet_out:
+ clk_disable_unprepare(fep->clk_ahb);
+
+ return ret;
+}
+
+static int fec_enet_mii_probe(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct phy_device *phy_dev = NULL;
+ char mdio_bus_id[MII_BUS_ID_SIZE];
+ char phy_name[MII_BUS_ID_SIZE + 3];
+ int phy_id;
+ int dev_id = fep->dev_id;
+
+ if (fep->phy_node) {
+ phy_dev = of_phy_connect(ndev, fep->phy_node,
+ &fec_enet_adjust_link, 0,
+ fep->phy_interface);
+ if (!phy_dev) {
+ netdev_err(ndev, "Unable to connect to phy\n");
+ return -ENODEV;
+ }
+ } else {
+ /* check for attached phy */
+ for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
+ if (!mdiobus_is_registered_device(fep->mii_bus, phy_id))
+ continue;
+ if (dev_id--)
+ continue;
+ strlcpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
+ break;
+ }
+
+ if (phy_id >= PHY_MAX_ADDR) {
+ netdev_info(ndev, "no PHY, assuming direct connection to switch\n");
+ strlcpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
+ phy_id = 0;
+ }
+
+ snprintf(phy_name, sizeof(phy_name),
+ PHY_ID_FMT, mdio_bus_id, phy_id);
+ phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link,
+ fep->phy_interface);
+ }
+
+ if (IS_ERR(phy_dev)) {
+ netdev_err(ndev, "could not attach to PHY\n");
+ return PTR_ERR(phy_dev);
+ }
+
+ /* mask with MAC supported features */
+ if (fep->quirks & FEC_QUIRK_HAS_GBIT) {
+ phy_dev->supported &= PHY_GBIT_FEATURES;
+ phy_dev->supported &= ~SUPPORTED_1000baseT_Half;
+#if !defined(CONFIG_M5272)
+ phy_dev->supported |= SUPPORTED_Pause;
+#endif
+ }
+ else
+ phy_dev->supported &= PHY_BASIC_FEATURES;
+
+ phy_dev->advertising = phy_dev->supported;
+
+ fep->link = 0;
+ fep->full_duplex = 0;
+
+ phy_attached_info(phy_dev);
+
+ return 0;
+}
+
+static int fec_enet_mii_init(struct platform_device *pdev)
+{
+ static struct mii_bus *fec0_mii_bus;
+ struct net_device *ndev = platform_get_drvdata(pdev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct device_node *node;
+ int err = -ENXIO;
+ u32 mii_speed, holdtime;
+
+ /*
+ * The i.MX28 dual fec interfaces are not equal.
+ * Here are the differences:
+ *
+ * - fec0 supports MII & RMII modes while fec1 only supports RMII
+ * - fec0 acts as the 1588 time master while fec1 is slave
+ * - external phys can only be configured by fec0
+ *
+ * That is to say fec1 can not work independently. It only works
+ * when fec0 is working. The reason behind this design is that the
+ * second interface is added primarily for Switch mode.
+ *
+ * Because of the last point above, both phys are attached on fec0
+ * mdio interface in board design, and need to be configured by
+ * fec0 mii_bus.
+ */
+ if ((fep->quirks & FEC_QUIRK_SINGLE_MDIO) && fep->dev_id > 0) {
+ /* fec1 uses fec0 mii_bus */
+ if (mii_cnt && fec0_mii_bus) {
+ fep->mii_bus = fec0_mii_bus;
+ mii_cnt++;
+ return 0;
+ }
+ return -ENOENT;
+ }
+
+ fep->mii_timeout = 0;
+
+ /*
+ * Set MII speed to 2.5 MHz (= clk_get_rate() / 2 * phy_speed)
+ *
+ * The formula for FEC MDC is 'ref_freq / (MII_SPEED x 2)' while
+ * for ENET-MAC is 'ref_freq / ((MII_SPEED + 1) x 2)'. The i.MX28
+ * Reference Manual has an error on this, and gets fixed on i.MX6Q
+ * document.
+ */
+ mii_speed = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), 5000000);
+ if (fep->quirks & FEC_QUIRK_ENET_MAC)
+ mii_speed--;
+ if (mii_speed > 63) {
+ dev_err(&pdev->dev,
+ "fec clock (%lu) too fast to get right mii speed\n",
+ clk_get_rate(fep->clk_ipg));
+ err = -EINVAL;
+ goto err_out;
+ }
+
+ /*
+ * The i.MX28 and i.MX6 types have another filed in the MSCR (aka
+ * MII_SPEED) register that defines the MDIO output hold time. Earlier
+ * versions are RAZ there, so just ignore the difference and write the
+ * register always.
+ * The minimal hold time according to IEE802.3 (clause 22) is 10 ns.
+ * HOLDTIME + 1 is the number of clk cycles the fec is holding the
+ * output.
+ * The HOLDTIME bitfield takes values between 0 and 7 (inclusive).
+ * Given that ceil(clkrate / 5000000) <= 64, the calculation for
+ * holdtime cannot result in a value greater than 3.
+ */
+ holdtime = DIV_ROUND_UP(clk_get_rate(fep->clk_ipg), 100000000) - 1;
+
+ fep->phy_speed = mii_speed << 1 | holdtime << 8;
+
+ writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
+
+ fep->mii_bus = mdiobus_alloc();
+ if (fep->mii_bus == NULL) {
+ err = -ENOMEM;
+ goto err_out;
+ }
+
+ fep->mii_bus->name = "fec_enet_mii_bus";
+ fep->mii_bus->read = fec_enet_mdio_read;
+ fep->mii_bus->write = fec_enet_mdio_write;
+ snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
+ pdev->name, fep->dev_id + 1);
+ fep->mii_bus->priv = fep;
+ fep->mii_bus->parent = &pdev->dev;
+
+ node = of_get_child_by_name(pdev->dev.of_node, "mdio");
+ if (node) {
+ err = of_mdiobus_register(fep->mii_bus, node);
+ of_node_put(node);
+ } else {
+ err = mdiobus_register(fep->mii_bus);
+ }
+
+ if (err)
+ goto err_out_free_mdiobus;
+
+ mii_cnt++;
+
+ /* save fec0 mii_bus */
+ if (fep->quirks & FEC_QUIRK_SINGLE_MDIO)
+ fec0_mii_bus = fep->mii_bus;
+
+ return 0;
+
+err_out_free_mdiobus:
+ mdiobus_free(fep->mii_bus);
+err_out:
+ return err;
+}
+
+static void fec_enet_mii_remove(struct fec_enet_private *fep)
+{
+ if (--mii_cnt == 0) {
+ mdiobus_unregister(fep->mii_bus);
+ mdiobus_free(fep->mii_bus);
+ }
+}
+
+static void fec_enet_get_drvinfo(struct net_device *ndev,
+ struct ethtool_drvinfo *info)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ strlcpy(info->driver, fep->pdev->dev.driver->name,
+ sizeof(info->driver));
+ strlcpy(info->version, "Revision: 1.0", sizeof(info->version));
+ strlcpy(info->bus_info, dev_name(&ndev->dev), sizeof(info->bus_info));
+}
+
+static int fec_enet_get_regs_len(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct resource *r;
+ int s = 0;
+
+ r = platform_get_resource(fep->pdev, IORESOURCE_MEM, 0);
+ if (r)
+ s = resource_size(r);
+
+ return s;
+}
+
+/* List of registers that can be safety be read to dump them with ethtool */
+#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
+ defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
+static u32 fec_enet_register_offset[] = {
+ FEC_IEVENT, FEC_IMASK, FEC_R_DES_ACTIVE_0, FEC_X_DES_ACTIVE_0,
+ FEC_ECNTRL, FEC_MII_DATA, FEC_MII_SPEED, FEC_MIB_CTRLSTAT, FEC_R_CNTRL,
+ FEC_X_CNTRL, FEC_ADDR_LOW, FEC_ADDR_HIGH, FEC_OPD, FEC_TXIC0, FEC_TXIC1,
+ FEC_TXIC2, FEC_RXIC0, FEC_RXIC1, FEC_RXIC2, FEC_HASH_TABLE_HIGH,
+ FEC_HASH_TABLE_LOW, FEC_GRP_HASH_TABLE_HIGH, FEC_GRP_HASH_TABLE_LOW,
+ FEC_X_WMRK, FEC_R_BOUND, FEC_R_FSTART, FEC_R_DES_START_1,
+ FEC_X_DES_START_1, FEC_R_BUFF_SIZE_1, FEC_R_DES_START_2,
+ FEC_X_DES_START_2, FEC_R_BUFF_SIZE_2, FEC_R_DES_START_0,
+ FEC_X_DES_START_0, FEC_R_BUFF_SIZE_0, FEC_R_FIFO_RSFL, FEC_R_FIFO_RSEM,
+ FEC_R_FIFO_RAEM, FEC_R_FIFO_RAFL, FEC_RACC, FEC_RCMR_1, FEC_RCMR_2,
+ FEC_DMA_CFG_1, FEC_DMA_CFG_2, FEC_R_DES_ACTIVE_1, FEC_X_DES_ACTIVE_1,
+ FEC_R_DES_ACTIVE_2, FEC_X_DES_ACTIVE_2, FEC_QOS_SCHEME,
+ RMON_T_DROP, RMON_T_PACKETS, RMON_T_BC_PKT, RMON_T_MC_PKT,
+ RMON_T_CRC_ALIGN, RMON_T_UNDERSIZE, RMON_T_OVERSIZE, RMON_T_FRAG,
+ RMON_T_JAB, RMON_T_COL, RMON_T_P64, RMON_T_P65TO127, RMON_T_P128TO255,
+ RMON_T_P256TO511, RMON_T_P512TO1023, RMON_T_P1024TO2047,
+ RMON_T_P_GTE2048, RMON_T_OCTETS,
+ IEEE_T_DROP, IEEE_T_FRAME_OK, IEEE_T_1COL, IEEE_T_MCOL, IEEE_T_DEF,
+ IEEE_T_LCOL, IEEE_T_EXCOL, IEEE_T_MACERR, IEEE_T_CSERR, IEEE_T_SQE,
+ IEEE_T_FDXFC, IEEE_T_OCTETS_OK,
+ RMON_R_PACKETS, RMON_R_BC_PKT, RMON_R_MC_PKT, RMON_R_CRC_ALIGN,
+ RMON_R_UNDERSIZE, RMON_R_OVERSIZE, RMON_R_FRAG, RMON_R_JAB,
+ RMON_R_RESVD_O, RMON_R_P64, RMON_R_P65TO127, RMON_R_P128TO255,
+ RMON_R_P256TO511, RMON_R_P512TO1023, RMON_R_P1024TO2047,
+ RMON_R_P_GTE2048, RMON_R_OCTETS,
+ IEEE_R_DROP, IEEE_R_FRAME_OK, IEEE_R_CRC, IEEE_R_ALIGN, IEEE_R_MACERR,
+ IEEE_R_FDXFC, IEEE_R_OCTETS_OK
+};
+#else
+static u32 fec_enet_register_offset[] = {
+ FEC_ECNTRL, FEC_IEVENT, FEC_IMASK, FEC_IVEC, FEC_R_DES_ACTIVE_0,
+ FEC_R_DES_ACTIVE_1, FEC_R_DES_ACTIVE_2, FEC_X_DES_ACTIVE_0,
+ FEC_X_DES_ACTIVE_1, FEC_X_DES_ACTIVE_2, FEC_MII_DATA, FEC_MII_SPEED,
+ FEC_R_BOUND, FEC_R_FSTART, FEC_X_WMRK, FEC_X_FSTART, FEC_R_CNTRL,
+ FEC_MAX_FRM_LEN, FEC_X_CNTRL, FEC_ADDR_LOW, FEC_ADDR_HIGH,
+ FEC_GRP_HASH_TABLE_HIGH, FEC_GRP_HASH_TABLE_LOW, FEC_R_DES_START_0,
+ FEC_R_DES_START_1, FEC_R_DES_START_2, FEC_X_DES_START_0,
+ FEC_X_DES_START_1, FEC_X_DES_START_2, FEC_R_BUFF_SIZE_0,
+ FEC_R_BUFF_SIZE_1, FEC_R_BUFF_SIZE_2
+};
+#endif
+
+static void fec_enet_get_regs(struct net_device *ndev,
+ struct ethtool_regs *regs, void *regbuf)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ u32 __iomem *theregs = (u32 __iomem *)fep->hwp;
+ u32 *buf = (u32 *)regbuf;
+ u32 i, off;
+
+ memset(buf, 0, regs->len);
+
+ for (i = 0; i < ARRAY_SIZE(fec_enet_register_offset); i++) {
+ off = fec_enet_register_offset[i] / 4;
+ buf[off] = readl(&theregs[off]);
+ }
+}
+
+static int fec_enet_get_ts_info(struct net_device *ndev,
+ struct ethtool_ts_info *info)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ if (fep->bufdesc_ex) {
+
+ info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
+ SOF_TIMESTAMPING_RX_SOFTWARE |
+ SOF_TIMESTAMPING_SOFTWARE |
+ SOF_TIMESTAMPING_TX_HARDWARE |
+ SOF_TIMESTAMPING_RX_HARDWARE |
+ SOF_TIMESTAMPING_RAW_HARDWARE;
+ if (fep->ptp_clock)
+ info->phc_index = ptp_clock_index(fep->ptp_clock);
+ else
+ info->phc_index = -1;
+
+ info->tx_types = (1 << HWTSTAMP_TX_OFF) |
+ (1 << HWTSTAMP_TX_ON);
+
+ info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
+ (1 << HWTSTAMP_FILTER_ALL);
+ return 0;
+ } else {
+ return ethtool_op_get_ts_info(ndev, info);
+ }
+}
+
+#if !defined(CONFIG_M5272)
+
+static void fec_enet_get_pauseparam(struct net_device *ndev,
+ struct ethtool_pauseparam *pause)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ pause->autoneg = (fep->pause_flag & FEC_PAUSE_FLAG_AUTONEG) != 0;
+ pause->tx_pause = (fep->pause_flag & FEC_PAUSE_FLAG_ENABLE) != 0;
+ pause->rx_pause = pause->tx_pause;
+}
+
+static int fec_enet_set_pauseparam(struct net_device *ndev,
+ struct ethtool_pauseparam *pause)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ if (!ndev->phydev)
+ return -ENODEV;
+
+ if (pause->tx_pause != pause->rx_pause) {
+ netdev_info(ndev,
+ "hardware only support enable/disable both tx and rx");
+ return -EINVAL;
+ }
+
+ fep->pause_flag = 0;
+
+ /* tx pause must be same as rx pause */
+ fep->pause_flag |= pause->rx_pause ? FEC_PAUSE_FLAG_ENABLE : 0;
+ fep->pause_flag |= pause->autoneg ? FEC_PAUSE_FLAG_AUTONEG : 0;
+
+ if (pause->rx_pause || pause->autoneg) {
+ ndev->phydev->supported |= ADVERTISED_Pause;
+ ndev->phydev->advertising |= ADVERTISED_Pause;
+ } else {
+ ndev->phydev->supported &= ~ADVERTISED_Pause;
+ ndev->phydev->advertising &= ~ADVERTISED_Pause;
+ }
+
+ if (pause->autoneg) {
+ if (if_running(ndev))
+ fec_stop(ndev);
+ phy_start_aneg(ndev->phydev);
+ }
+ if (if_running(ndev)) {
+ if_lock(ndev);
+ fec_restart(ndev);
+ if_wake_unlock(ndev, false);
+ }
+
+ return 0;
+}
+
+static const struct fec_stat {
+ char name[ETH_GSTRING_LEN];
+ u16 offset;
+} fec_stats[] = {
+ /* RMON TX */
+ { "tx_dropped", RMON_T_DROP },
+ { "tx_packets", RMON_T_PACKETS },
+ { "tx_broadcast", RMON_T_BC_PKT },
+ { "tx_multicast", RMON_T_MC_PKT },
+ { "tx_crc_errors", RMON_T_CRC_ALIGN },
+ { "tx_undersize", RMON_T_UNDERSIZE },
+ { "tx_oversize", RMON_T_OVERSIZE },
+ { "tx_fragment", RMON_T_FRAG },
+ { "tx_jabber", RMON_T_JAB },
+ { "tx_collision", RMON_T_COL },
+ { "tx_64byte", RMON_T_P64 },
+ { "tx_65to127byte", RMON_T_P65TO127 },
+ { "tx_128to255byte", RMON_T_P128TO255 },
+ { "tx_256to511byte", RMON_T_P256TO511 },
+ { "tx_512to1023byte", RMON_T_P512TO1023 },
+ { "tx_1024to2047byte", RMON_T_P1024TO2047 },
+ { "tx_GTE2048byte", RMON_T_P_GTE2048 },
+ { "tx_octets", RMON_T_OCTETS },
+
+ /* IEEE TX */
+ { "IEEE_tx_drop", IEEE_T_DROP },
+ { "IEEE_tx_frame_ok", IEEE_T_FRAME_OK },
+ { "IEEE_tx_1col", IEEE_T_1COL },
+ { "IEEE_tx_mcol", IEEE_T_MCOL },
+ { "IEEE_tx_def", IEEE_T_DEF },
+ { "IEEE_tx_lcol", IEEE_T_LCOL },
+ { "IEEE_tx_excol", IEEE_T_EXCOL },
+ { "IEEE_tx_macerr", IEEE_T_MACERR },
+ { "IEEE_tx_cserr", IEEE_T_CSERR },
+ { "IEEE_tx_sqe", IEEE_T_SQE },
+ { "IEEE_tx_fdxfc", IEEE_T_FDXFC },
+ { "IEEE_tx_octets_ok", IEEE_T_OCTETS_OK },
+
+ /* RMON RX */
+ { "rx_packets", RMON_R_PACKETS },
+ { "rx_broadcast", RMON_R_BC_PKT },
+ { "rx_multicast", RMON_R_MC_PKT },
+ { "rx_crc_errors", RMON_R_CRC_ALIGN },
+ { "rx_undersize", RMON_R_UNDERSIZE },
+ { "rx_oversize", RMON_R_OVERSIZE },
+ { "rx_fragment", RMON_R_FRAG },
+ { "rx_jabber", RMON_R_JAB },
+ { "rx_64byte", RMON_R_P64 },
+ { "rx_65to127byte", RMON_R_P65TO127 },
+ { "rx_128to255byte", RMON_R_P128TO255 },
+ { "rx_256to511byte", RMON_R_P256TO511 },
+ { "rx_512to1023byte", RMON_R_P512TO1023 },
+ { "rx_1024to2047byte", RMON_R_P1024TO2047 },
+ { "rx_GTE2048byte", RMON_R_P_GTE2048 },
+ { "rx_octets", RMON_R_OCTETS },
+
+ /* IEEE RX */
+ { "IEEE_rx_drop", IEEE_R_DROP },
+ { "IEEE_rx_frame_ok", IEEE_R_FRAME_OK },
+ { "IEEE_rx_crc", IEEE_R_CRC },
+ { "IEEE_rx_align", IEEE_R_ALIGN },
+ { "IEEE_rx_macerr", IEEE_R_MACERR },
+ { "IEEE_rx_fdxfc", IEEE_R_FDXFC },
+ { "IEEE_rx_octets_ok", IEEE_R_OCTETS_OK },
+};
+
+#define FEC_STATS_SIZE (ARRAY_SIZE(fec_stats) * sizeof(u64))
+
+static void fec_enet_update_ethtool_stats(struct net_device *dev)
+{
+ struct fec_enet_private *fep = netdev_priv(dev);
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(fec_stats); i++)
+ fep->ethtool_stats[i] = readl(fep->hwp + fec_stats[i].offset);
+}
+
+static void fec_enet_get_ethtool_stats(struct net_device *dev,
+ struct ethtool_stats *stats, u64 *data)
+{
+ struct fec_enet_private *fep = netdev_priv(dev);
+
+ if (if_running(dev))
+ fec_enet_update_ethtool_stats(dev);
+
+ memcpy(data, fep->ethtool_stats, FEC_STATS_SIZE);
+}
+
+static void fec_enet_get_strings(struct net_device *netdev,
+ u32 stringset, u8 *data)
+{
+ int i;
+ switch (stringset) {
+ case ETH_SS_STATS:
+ for (i = 0; i < ARRAY_SIZE(fec_stats); i++)
+ memcpy(data + i * ETH_GSTRING_LEN,
+ fec_stats[i].name, ETH_GSTRING_LEN);
+ break;
+ }
+}
+
+static int fec_enet_get_sset_count(struct net_device *dev, int sset)
+{
+ switch (sset) {
+ case ETH_SS_STATS:
+ return ARRAY_SIZE(fec_stats);
+ default:
+ return -EOPNOTSUPP;
+ }
+}
+
+static void fec_enet_clear_ethtool_stats(struct net_device *dev)
+{
+ struct fec_enet_private *fep = netdev_priv(dev);
+ int i;
+
+ /* Disable MIB statistics counters */
+ writel(FEC_MIB_CTRLSTAT_DISABLE, fep->hwp + FEC_MIB_CTRLSTAT);
+
+ for (i = 0; i < ARRAY_SIZE(fec_stats); i++)
+ writel(0, fep->hwp + fec_stats[i].offset);
+
+ /* Don't disable MIB statistics counters */
+ writel(0, fep->hwp + FEC_MIB_CTRLSTAT);
+}
+
+#else /* !defined(CONFIG_M5272) */
+#define FEC_STATS_SIZE 0
+static inline void fec_enet_update_ethtool_stats(struct net_device *dev)
+{
+}
+
+static inline void fec_enet_clear_ethtool_stats(struct net_device *dev)
+{
+}
+#endif /* !defined(CONFIG_M5272) */
+
+/* ITR clock source is enet system clock (clk_ahb).
+ * TCTT unit is cycle_ns * 64 cycle
+ * So, the ICTT value = X us / (cycle_ns * 64)
+ */
+static int fec_enet_us_to_itr_clock(struct net_device *ndev, int us)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ return us * (fep->itr_clk_rate / 64000) / 1000;
+}
+
+/* Set threshold for interrupt coalescing */
+static void fec_enet_itr_coal_set(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int rx_itr, tx_itr;
+
+ /* Must be greater than zero to avoid unpredictable behavior */
+ if (!fep->rx_time_itr || !fep->rx_pkts_itr ||
+ !fep->tx_time_itr || !fep->tx_pkts_itr)
+ return;
+
+ /* Select enet system clock as Interrupt Coalescing
+ * timer Clock Source
+ */
+ rx_itr = FEC_ITR_CLK_SEL;
+ tx_itr = FEC_ITR_CLK_SEL;
+
+ /* set ICFT and ICTT */
+ rx_itr |= FEC_ITR_ICFT(fep->rx_pkts_itr);
+ rx_itr |= FEC_ITR_ICTT(fec_enet_us_to_itr_clock(ndev, fep->rx_time_itr));
+ tx_itr |= FEC_ITR_ICFT(fep->tx_pkts_itr);
+ tx_itr |= FEC_ITR_ICTT(fec_enet_us_to_itr_clock(ndev, fep->tx_time_itr));
+
+ rx_itr |= FEC_ITR_EN;
+ tx_itr |= FEC_ITR_EN;
+
+ writel(tx_itr, fep->hwp + FEC_TXIC0);
+ writel(rx_itr, fep->hwp + FEC_RXIC0);
+ if (fep->quirks & FEC_QUIRK_HAS_AVB) {
+ writel(tx_itr, fep->hwp + FEC_TXIC1);
+ writel(rx_itr, fep->hwp + FEC_RXIC1);
+ writel(tx_itr, fep->hwp + FEC_TXIC2);
+ writel(rx_itr, fep->hwp + FEC_RXIC2);
+ }
+}
+
+static int
+fec_enet_get_coalesce(struct net_device *ndev, struct ethtool_coalesce *ec)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ if (!(fep->quirks & FEC_QUIRK_HAS_COALESCE))
+ return -EOPNOTSUPP;
+
+ ec->rx_coalesce_usecs = fep->rx_time_itr;
+ ec->rx_max_coalesced_frames = fep->rx_pkts_itr;
+
+ ec->tx_coalesce_usecs = fep->tx_time_itr;
+ ec->tx_max_coalesced_frames = fep->tx_pkts_itr;
+
+ return 0;
+}
+
+static int
+fec_enet_set_coalesce(struct net_device *ndev, struct ethtool_coalesce *ec)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ unsigned int cycle;
+
+ if (!(fep->quirks & FEC_QUIRK_HAS_COALESCE))
+ return -EOPNOTSUPP;
+
+ if (ec->rx_max_coalesced_frames > 255) {
+ pr_err("Rx coalesced frames exceed hardware limitation\n");
+ return -EINVAL;
+ }
+
+ if (ec->tx_max_coalesced_frames > 255) {
+ pr_err("Tx coalesced frame exceed hardware limitation\n");
+ return -EINVAL;
+ }
+
+ cycle = fec_enet_us_to_itr_clock(ndev, fep->rx_time_itr);
+ if (cycle > 0xFFFF) {
+ pr_err("Rx coalesced usec exceed hardware limitation\n");
+ return -EINVAL;
+ }
+
+ cycle = fec_enet_us_to_itr_clock(ndev, fep->tx_time_itr);
+ if (cycle > 0xFFFF) {
+ pr_err("Rx coalesced usec exceed hardware limitation\n");
+ return -EINVAL;
+ }
+
+ fep->rx_time_itr = ec->rx_coalesce_usecs;
+ fep->rx_pkts_itr = ec->rx_max_coalesced_frames;
+
+ fep->tx_time_itr = ec->tx_coalesce_usecs;
+ fep->tx_pkts_itr = ec->tx_max_coalesced_frames;
+
+ fec_enet_itr_coal_set(ndev);
+
+ return 0;
+}
+
+static void fec_enet_itr_coal_init(struct net_device *ndev)
+{
+ struct ethtool_coalesce ec;
+
+ ec.rx_coalesce_usecs = FEC_ITR_ICTT_DEFAULT;
+ ec.rx_max_coalesced_frames = FEC_ITR_ICFT_DEFAULT;
+
+ ec.tx_coalesce_usecs = FEC_ITR_ICTT_DEFAULT;
+ ec.tx_max_coalesced_frames = FEC_ITR_ICFT_DEFAULT;
+
+ fec_enet_set_coalesce(ndev, &ec);
+}
+
+static int fec_enet_get_tunable(struct net_device *netdev,
+ const struct ethtool_tunable *tuna,
+ void *data)
+{
+ struct fec_enet_private *fep = netdev_priv(netdev);
+ int ret = 0;
+
+ switch (tuna->id) {
+ case ETHTOOL_RX_COPYBREAK:
+ *(u32 *)data = fep->rx_copybreak;
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+static int fec_enet_set_tunable(struct net_device *netdev,
+ const struct ethtool_tunable *tuna,
+ const void *data)
+{
+ struct fec_enet_private *fep = netdev_priv(netdev);
+ int ret = 0;
+
+ switch (tuna->id) {
+ case ETHTOOL_RX_COPYBREAK:
+ fep->rx_copybreak = *(u32 *)data;
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+static void
+fec_enet_get_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ if (fep->wol_flag & FEC_WOL_HAS_MAGIC_PACKET) {
+ wol->supported = WAKE_MAGIC;
+ wol->wolopts = fep->wol_flag & FEC_WOL_FLAG_ENABLE ? WAKE_MAGIC : 0;
+ } else {
+ wol->supported = wol->wolopts = 0;
+ }
+}
+
+static int
+fec_enet_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ if (!(fep->wol_flag & FEC_WOL_HAS_MAGIC_PACKET))
+ return -EINVAL;
+
+ if (wol->wolopts & ~WAKE_MAGIC)
+ return -EINVAL;
+
+ device_set_wakeup_enable(&ndev->dev, wol->wolopts & WAKE_MAGIC);
+ if (device_may_wakeup(&ndev->dev)) {
+ fep->wol_flag |= FEC_WOL_FLAG_ENABLE;
+ if (fep->irq[0] > 0)
+ enable_irq_wake(fep->irq[0]);
+ } else {
+ fep->wol_flag &= (~FEC_WOL_FLAG_ENABLE);
+ if (fep->irq[0] > 0)
+ disable_irq_wake(fep->irq[0]);
+ }
+
+ return 0;
+}
+
+static const struct ethtool_ops fec_enet_ethtool_ops = {
+ .get_drvinfo = fec_enet_get_drvinfo,
+ .get_regs_len = fec_enet_get_regs_len,
+ .get_regs = fec_enet_get_regs,
+ .nway_reset = phy_ethtool_nway_reset,
+ .get_link = ethtool_op_get_link,
+ .get_coalesce = fec_enet_get_coalesce,
+ .set_coalesce = fec_enet_set_coalesce,
+#ifndef CONFIG_M5272
+ .get_pauseparam = fec_enet_get_pauseparam,
+ .set_pauseparam = fec_enet_set_pauseparam,
+ .get_strings = fec_enet_get_strings,
+ .get_ethtool_stats = fec_enet_get_ethtool_stats,
+ .get_sset_count = fec_enet_get_sset_count,
+#endif
+ .get_ts_info = fec_enet_get_ts_info,
+ .get_tunable = fec_enet_get_tunable,
+ .set_tunable = fec_enet_set_tunable,
+ .get_wol = fec_enet_get_wol,
+ .set_wol = fec_enet_set_wol,
+ .get_link_ksettings = phy_ethtool_get_link_ksettings,
+ .set_link_ksettings = phy_ethtool_set_link_ksettings,
+};
+
+static int fec_enet_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct phy_device *phydev = ndev->phydev;
+
+ if (!if_running(ndev))
+ return -EINVAL;
+
+ if (!phydev)
+ return -ENODEV;
+
+ if (fep->bufdesc_ex) {
+ if (cmd == SIOCSHWTSTAMP)
+ return fec_ptp_set(ndev, rq);
+ if (cmd == SIOCGHWTSTAMP)
+ return fec_ptp_get(ndev, rq);
+ }
+
+ return phy_mii_ioctl(phydev, rq, cmd);
+}
+
+static int fec_rt_ioctl(struct rtnet_device *rtdev, struct ifreq *rq, int cmd)
+{
+ struct fec_enet_private *fep;
+
+ fep = container_of(rtdev, struct fec_enet_private, rtnet.dev);
+
+ return fec_enet_ioctl(fep->netdev, rq, cmd);
+}
+
+static void fec_enet_free_buffers(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ unsigned int i;
+ void *skb;
+ struct bufdesc *bdp;
+ struct fec_enet_priv_tx_q *txq;
+ struct fec_enet_priv_rx_q *rxq;
+ unsigned int q, size;
+
+ for (q = 0; q < fep->num_rx_queues; q++) {
+ rxq = fep->rx_queue[q];
+ bdp = rxq->bd.base;
+ for (i = 0; i < rxq->bd.ring_size; i++) {
+ skb = rxq->rx_skbuff[i];
+ if (!skb)
+ goto skip;
+ rxq->rx_skbuff[i] = NULL;
+ if (!fep->rtnet.enabled) {
+ dev_kfree_skb(skb);
+ size = FEC_ENET_RX_FRSIZE;
+ } else {
+ dev_kfree_rtskb(skb);
+ size = RTSKB_SIZE;
+ }
+
+ dma_unmap_single(&fep->pdev->dev,
+ fec32_to_cpu(bdp->cbd_bufaddr),
+ size - fep->rx_align,
+ DMA_FROM_DEVICE);
+ skip:
+ bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
+ }
+ }
+
+ for (q = 0; q < fep->num_tx_queues; q++) {
+ txq = fep->tx_queue[q];
+ bdp = txq->bd.base;
+ for (i = 0; i < txq->bd.ring_size; i++) {
+ kfree(txq->tx_bounce[i]);
+ txq->tx_bounce[i] = NULL;
+ skb = txq->tx_skbuff[i];
+ if (!skb)
+ continue;
+ txq->tx_skbuff[i] = NULL;
+ if (!fep->rtnet.enabled)
+ dev_kfree_skb(skb);
+ else
+ dev_kfree_rtskb(skb);
+ }
+ }
+}
+
+static void fec_enet_free_queue(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int i;
+ struct fec_enet_priv_tx_q *txq;
+
+ for (i = 0; i < fep->num_tx_queues; i++)
+ if (fep->tx_queue[i] && fep->tx_queue[i]->tso_hdrs) {
+ txq = fep->tx_queue[i];
+ dma_free_coherent(&fep->pdev->dev,
+ txq->bd.ring_size * TSO_HEADER_SIZE,
+ txq->tso_hdrs,
+ txq->tso_hdrs_dma);
+ }
+
+ for (i = 0; i < fep->num_rx_queues; i++)
+ kfree(fep->rx_queue[i]);
+ for (i = 0; i < fep->num_tx_queues; i++)
+ kfree(fep->tx_queue[i]);
+}
+
+static int fec_enet_alloc_queue(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int i;
+ int ret = 0;
+ struct fec_enet_priv_tx_q *txq;
+
+ for (i = 0; i < fep->num_tx_queues; i++) {
+ txq = kzalloc(sizeof(*txq), GFP_KERNEL);
+ if (!txq) {
+ ret = -ENOMEM;
+ goto alloc_failed;
+ }
+
+ fep->tx_queue[i] = txq;
+ txq->bd.ring_size = TX_RING_SIZE;
+ fep->total_tx_ring_size += fep->tx_queue[i]->bd.ring_size;
+
+ txq->tx_stop_threshold = FEC_MAX_SKB_DESCS;
+ txq->tx_wake_threshold =
+ (txq->bd.ring_size - txq->tx_stop_threshold) / 2;
+
+ txq->tso_hdrs = dma_alloc_coherent(&fep->pdev->dev,
+ txq->bd.ring_size * TSO_HEADER_SIZE,
+ &txq->tso_hdrs_dma,
+ GFP_KERNEL);
+ if (!txq->tso_hdrs) {
+ ret = -ENOMEM;
+ goto alloc_failed;
+ }
+ }
+
+ for (i = 0; i < fep->num_rx_queues; i++) {
+ fep->rx_queue[i] = kzalloc(sizeof(*fep->rx_queue[i]),
+ GFP_KERNEL);
+ if (!fep->rx_queue[i]) {
+ ret = -ENOMEM;
+ goto alloc_failed;
+ }
+
+ fep->rx_queue[i]->bd.ring_size = RX_RING_SIZE;
+ fep->total_rx_ring_size += fep->rx_queue[i]->bd.ring_size;
+ }
+ return ret;
+
+alloc_failed:
+ fec_enet_free_queue(ndev);
+ return ret;
+}
+
+static int
+fec_enet_alloc_rxq_buffers(struct net_device *ndev, unsigned int queue)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ unsigned int i;
+ struct sk_buff *skb;
+ struct rtskb *rtskb;
+ struct bufdesc *bdp;
+ struct fec_enet_priv_rx_q *rxq;
+
+ rxq = fep->rx_queue[queue];
+ bdp = rxq->bd.base;
+ for (i = 0; i < rxq->bd.ring_size; i++) {
+ if (frt->enabled) {
+ rtskb = rtnetdev_alloc_rtskb(&frt->dev, RTSKB_SIZE);
+ if (!rtskb)
+ goto err_alloc;
+
+ if (fec_rt_new_rxbdp(ndev, bdp, rtskb)) {
+ dev_kfree_rtskb(rtskb);
+ goto err_alloc;
+ }
+ rxq->rx_rtbuff[i] = rtskb;
+ } else {
+ skb = netdev_alloc_skb(ndev, FEC_ENET_RX_FRSIZE);
+ if (!skb)
+ goto err_alloc;
+
+ if (fec_enet_new_rxbdp(ndev, bdp, skb)) {
+ dev_kfree_skb(skb);
+ goto err_alloc;
+ }
+
+ rxq->rx_skbuff[i] = skb;
+ }
+ bdp->cbd_sc = cpu_to_fec16(BD_ENET_RX_EMPTY);
+
+ if (fep->bufdesc_ex) {
+ struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
+ ebdp->cbd_esc = cpu_to_fec32(BD_ENET_RX_INT);
+ }
+
+ bdp = fec_enet_get_nextdesc(bdp, &rxq->bd);
+ }
+
+ /* Set the last buffer to wrap. */
+ bdp = fec_enet_get_prevdesc(bdp, &rxq->bd);
+ bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
+ return 0;
+
+ err_alloc:
+ fec_enet_free_buffers(ndev);
+ return -ENOMEM;
+}
+
+static int
+fec_enet_alloc_txq_buffers(struct net_device *ndev, unsigned int queue)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ unsigned int i;
+ struct bufdesc *bdp;
+ struct fec_enet_priv_tx_q *txq;
+
+ txq = fep->tx_queue[queue];
+ bdp = txq->bd.base;
+ for (i = 0; i < txq->bd.ring_size; i++) {
+ txq->tx_bounce[i] = kmalloc(FEC_ENET_TX_FRSIZE, GFP_KERNEL);
+ if (!txq->tx_bounce[i])
+ goto err_alloc;
+
+ bdp->cbd_sc = cpu_to_fec16(0);
+ bdp->cbd_bufaddr = cpu_to_fec32(0);
+
+ if (fep->bufdesc_ex) {
+ struct bufdesc_ex *ebdp = (struct bufdesc_ex *)bdp;
+ ebdp->cbd_esc = cpu_to_fec32(BD_ENET_TX_INT);
+ }
+
+ bdp = fec_enet_get_nextdesc(bdp, &txq->bd);
+ }
+
+ /* Set the last buffer to wrap. */
+ bdp = fec_enet_get_prevdesc(bdp, &txq->bd);
+ bdp->cbd_sc |= cpu_to_fec16(BD_SC_WRAP);
+
+ return 0;
+
+ err_alloc:
+ fec_enet_free_buffers(ndev);
+ return -ENOMEM;
+}
+
+static int fec_enet_alloc_buffers(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ unsigned int i;
+
+ for (i = 0; i < fep->num_rx_queues; i++)
+ if (fec_enet_alloc_rxq_buffers(ndev, i))
+ return -ENOMEM;
+
+ for (i = 0; i < fep->num_tx_queues; i++)
+ if (fec_enet_alloc_txq_buffers(ndev, i))
+ return -ENOMEM;
+
+ return 0;
+}
+
+static int
+__fec_enet_open(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ int ret;
+
+ ret = pm_runtime_get_sync(&fep->pdev->dev);
+ if (ret < 0)
+ return ret;
+
+ pinctrl_pm_select_default_state(&fep->pdev->dev);
+ ret = fec_enet_clk_enable(ndev, true);
+ if (ret)
+ goto clk_enable;
+
+ /* I should reset the ring buffers here, but I don't yet know
+ * a simple way to do that.
+ */
+
+ ret = fec_enet_alloc_buffers(ndev);
+ if (ret)
+ goto err_enet_alloc;
+
+ /* Init MAC prior to mii bus probe */
+ fec_restart(ndev);
+
+ /* Probe and connect to PHY when open the interface */
+ ret = fec_enet_mii_probe(ndev);
+ if (ret)
+ goto err_enet_mii_probe;
+
+ if (fep->quirks & FEC_QUIRK_ERR006687)
+ imx6q_cpuidle_fec_irqs_used();
+
+ napi_enable(&fep->napi);
+ phy_start(ndev->phydev);
+ netif_tx_start_all_queues(ndev);
+
+ device_set_wakeup_enable(&ndev->dev, fep->wol_flag &
+ FEC_WOL_FLAG_ENABLE);
+
+ return 0;
+
+err_enet_mii_probe:
+ fec_enet_free_buffers(ndev);
+err_enet_alloc:
+ fec_enet_clk_enable(ndev, false);
+clk_enable:
+ pm_runtime_mark_last_busy(&fep->pdev->dev);
+ pm_runtime_put_autosuspend(&fep->pdev->dev);
+ pinctrl_pm_select_sleep_state(&fep->pdev->dev);
+ return ret;
+}
+
+static int
+fec_enet_open(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ if (frt->enabled)
+ return -EBUSY;
+
+ return __fec_enet_open(ndev);
+}
+
+static int
+fec_rt_open(struct rtnet_device *rtdev)
+{
+ struct fec_enet_private *fep;
+ int ret;
+
+ fep = container_of(rtdev, struct fec_enet_private, rtnet.dev);
+ ret = __fec_enet_open(fep->netdev);
+ if (ret)
+ return ret;
+
+ rt_stack_connect(rtdev, &STACK_manager);
+ rtnetif_start_queue(rtdev);
+
+ return 0;
+}
+
+static int
+fec_enet_close(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ phy_stop(ndev->phydev);
+
+ if (netif_device_present(ndev)) {
+ napi_disable(&fep->napi);
+ netif_tx_disable(ndev);
+ fec_stop(ndev);
+ }
+
+ phy_disconnect(ndev->phydev);
+
+ if (fep->quirks & FEC_QUIRK_ERR006687)
+ imx6q_cpuidle_fec_irqs_unused();
+
+ fec_enet_update_ethtool_stats(ndev);
+
+ fec_enet_clk_enable(ndev, false);
+ pinctrl_pm_select_sleep_state(&fep->pdev->dev);
+ pm_runtime_mark_last_busy(&fep->pdev->dev);
+ pm_runtime_put_autosuspend(&fep->pdev->dev);
+
+ fec_enet_free_buffers(ndev);
+
+ return 0;
+}
+
+static int
+fec_rt_close(struct rtnet_device *rtdev)
+{
+ struct fec_enet_private *fep;
+
+ fep = container_of(rtdev, struct fec_enet_private, rtnet.dev);
+ rtnetif_stop_queue(rtdev);
+ rtnetif_carrier_off(rtdev);
+ rt_stack_disconnect(rtdev);
+
+ return fec_enet_close(fep->netdev);
+}
+
+/* Set or clear the multicast filter for this adaptor.
+ * Skeleton taken from sunlance driver.
+ * The CPM Ethernet implementation allows Multicast as well as individual
+ * MAC address filtering. Some of the drivers check to make sure it is
+ * a group multicast address, and discard those that are not. I guess I
+ * will do the same for now, but just remove the test if you want
+ * individual filtering as well (do the upper net layers want or support
+ * this kind of feature?).
+ */
+
+#define FEC_HASH_BITS 6 /* #bits in hash */
+#define CRC32_POLY 0xEDB88320
+
+static void set_multicast_list(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct netdev_hw_addr *ha;
+ unsigned int i, bit, data, crc, tmp;
+ unsigned char hash;
+ unsigned int hash_high = 0, hash_low = 0;
+
+ if (ndev->flags & IFF_PROMISC) {
+ tmp = readl(fep->hwp + FEC_R_CNTRL);
+ tmp |= 0x8;
+ writel(tmp, fep->hwp + FEC_R_CNTRL);
+ return;
+ }
+
+ tmp = readl(fep->hwp + FEC_R_CNTRL);
+ tmp &= ~0x8;
+ writel(tmp, fep->hwp + FEC_R_CNTRL);
+
+ if (ndev->flags & IFF_ALLMULTI) {
+ /* Catch all multicast addresses, so set the
+ * filter to all 1's
+ */
+ writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+ writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+
+ return;
+ }
+
+ /* Add the addresses in hash register */
+ netdev_for_each_mc_addr(ha, ndev) {
+ /* calculate crc32 value of mac address */
+ crc = 0xffffffff;
+
+ for (i = 0; i < ndev->addr_len; i++) {
+ data = ha->addr[i];
+ for (bit = 0; bit < 8; bit++, data >>= 1) {
+ crc = (crc >> 1) ^
+ (((crc ^ data) & 1) ? CRC32_POLY : 0);
+ }
+ }
+
+ /* only upper 6 bits (FEC_HASH_BITS) are used
+ * which point to specific bit in the hash registers
+ */
+ hash = (crc >> (32 - FEC_HASH_BITS)) & 0x3f;
+
+ if (hash > 31)
+ hash_high |= 1 << (hash - 32);
+ else
+ hash_low |= 1 << hash;
+ }
+
+ writel(hash_high, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+ writel(hash_low, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+}
+
+/* Set a MAC change in hardware. */
+static int
+fec_set_mac_address(struct net_device *ndev, void *p)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct sockaddr *addr = p;
+
+ if (addr) {
+ if (!is_valid_ether_addr(addr->sa_data))
+ return -EADDRNOTAVAIL;
+ memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
+ }
+
+ /* Add netif status check here to avoid system hang in below case:
+ * ifconfig ethx down; ifconfig ethx hw ether xx:xx:xx:xx:xx:xx;
+ * After ethx down, fec all clocks are gated off and then register
+ * access causes system hang.
+ */
+ if (!if_running(ndev))
+ return 0;
+
+ writel(ndev->dev_addr[3] | (ndev->dev_addr[2] << 8) |
+ (ndev->dev_addr[1] << 16) | (ndev->dev_addr[0] << 24),
+ fep->hwp + FEC_ADDR_LOW);
+ writel((ndev->dev_addr[5] << 16) | (ndev->dev_addr[4] << 24),
+ fep->hwp + FEC_ADDR_HIGH);
+ return 0;
+}
+
+#ifdef CONFIG_NET_POLL_CONTROLLER
+/**
+ * fec_poll_controller - FEC Poll controller function
+ * @dev: The FEC network adapter
+ *
+ * Polled functionality used by netconsole and others in non interrupt mode
+ *
+ */
+static void fec_poll_controller(struct net_device *dev)
+{
+ int i;
+ struct fec_enet_private *fep = netdev_priv(dev);
+
+ for (i = 0; i < FEC_IRQ_NUM; i++) {
+ if (fep->irq[i] > 0) {
+ disable_irq(fep->irq[i]);
+ fec_enet_interrupt(fep->irq[i], dev);
+ enable_irq(fep->irq[i]);
+ }
+ }
+}
+#endif
+
+static inline void fec_enet_set_netdev_features(struct net_device *netdev,
+ netdev_features_t features)
+{
+ struct fec_enet_private *fep = netdev_priv(netdev);
+ netdev_features_t changed = features ^ netdev->features;
+
+ netdev->features = features;
+
+ /* Receive checksum has been changed */
+ if (changed & NETIF_F_RXCSUM) {
+ if (features & NETIF_F_RXCSUM)
+ fep->csum_flags |= FLAG_RX_CSUM_ENABLED;
+ else
+ fep->csum_flags &= ~FLAG_RX_CSUM_ENABLED;
+ }
+}
+
+static int fec_set_features(struct net_device *netdev,
+ netdev_features_t features)
+{
+ netdev_features_t changed = features ^ netdev->features;
+
+ if (if_running(netdev) && changed & NETIF_F_RXCSUM) {
+ if_lock(netdev);
+ fec_stop(netdev);
+ fec_enet_set_netdev_features(netdev, features);
+ fec_restart(netdev);
+ if_wake_unlock(netdev, true);
+ } else {
+ fec_enet_set_netdev_features(netdev, features);
+ }
+
+ return 0;
+}
+
+static const struct net_device_ops fec_netdev_ops = {
+ .ndo_open = fec_enet_open,
+ .ndo_stop = fec_enet_close,
+ .ndo_start_xmit = fec_enet_start_xmit,
+ .ndo_set_rx_mode = set_multicast_list,
+ .ndo_validate_addr = eth_validate_addr,
+ .ndo_tx_timeout = fec_timeout,
+ .ndo_set_mac_address = fec_set_mac_address,
+ .ndo_do_ioctl = fec_enet_ioctl,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+ .ndo_poll_controller = fec_poll_controller,
+#endif
+ .ndo_set_features = fec_set_features,
+};
+
+static const unsigned short offset_des_active_rxq[] = {
+ FEC_R_DES_ACTIVE_0, FEC_R_DES_ACTIVE_1, FEC_R_DES_ACTIVE_2
+};
+
+static const unsigned short offset_des_active_txq[] = {
+ FEC_X_DES_ACTIVE_0, FEC_X_DES_ACTIVE_1, FEC_X_DES_ACTIVE_2
+};
+
+/*
+ * XXX: We need to clean up on failure exits here.
+ *
+ */
+static int fec_enet_init(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ struct bufdesc *cbd_base;
+ dma_addr_t bd_dma;
+ int bd_size;
+ unsigned int i;
+ unsigned dsize = fep->bufdesc_ex ? sizeof(struct bufdesc_ex) :
+ sizeof(struct bufdesc);
+ unsigned dsize_log2 = __fls(dsize);
+
+ WARN_ON(dsize != (1 << dsize_log2));
+#if defined(CONFIG_ARM)
+ fep->rx_align = 0xf;
+ fep->tx_align = 0xf;
+#else
+ fep->rx_align = 0x3;
+ fep->tx_align = 0x3;
+#endif
+
+ fec_enet_alloc_queue(ndev);
+
+ bd_size = (fep->total_tx_ring_size + fep->total_rx_ring_size) * dsize;
+
+ /* Allocate memory for buffer descriptors. */
+ cbd_base = dmam_alloc_coherent(&fep->pdev->dev, bd_size, &bd_dma,
+ GFP_KERNEL);
+ if (!cbd_base) {
+ return -ENOMEM;
+ }
+
+ memset(cbd_base, 0, bd_size);
+
+ /* Get the Ethernet address */
+ fec_get_mac(ndev);
+ /* make sure MAC we just acquired is programmed into the hw */
+ fec_set_mac_address(ndev, NULL);
+
+ if (frt->enabled)
+ memcpy(&frt->dev.dev_addr, ndev->dev_addr, ETH_ALEN);
+
+ /* Set receive and transmit descriptor base. */
+ for (i = 0; i < fep->num_rx_queues; i++) {
+ struct fec_enet_priv_rx_q *rxq = fep->rx_queue[i];
+ unsigned size = dsize * rxq->bd.ring_size;
+
+ rxq->bd.qid = i;
+ rxq->bd.base = cbd_base;
+ rxq->bd.cur = cbd_base;
+ rxq->bd.dma = bd_dma;
+ rxq->bd.dsize = dsize;
+ rxq->bd.dsize_log2 = dsize_log2;
+ rxq->bd.reg_desc_active = fep->hwp + offset_des_active_rxq[i];
+ bd_dma += size;
+ cbd_base = (struct bufdesc *)(((void *)cbd_base) + size);
+ rxq->bd.last = (struct bufdesc *)(((void *)cbd_base) - dsize);
+ }
+
+ for (i = 0; i < fep->num_tx_queues; i++) {
+ struct fec_enet_priv_tx_q *txq = fep->tx_queue[i];
+ unsigned size = dsize * txq->bd.ring_size;
+
+ txq->bd.qid = i;
+ txq->bd.base = cbd_base;
+ txq->bd.cur = cbd_base;
+ txq->bd.dma = bd_dma;
+ txq->bd.dsize = dsize;
+ txq->bd.dsize_log2 = dsize_log2;
+ txq->bd.reg_desc_active = fep->hwp + offset_des_active_txq[i];
+ bd_dma += size;
+ cbd_base = (struct bufdesc *)(((void *)cbd_base) + size);
+ txq->bd.last = (struct bufdesc *)(((void *)cbd_base) - dsize);
+ }
+
+
+ /* The FEC Ethernet specific entries in the device structure */
+ ndev->watchdog_timeo = TX_TIMEOUT;
+ ndev->netdev_ops = &fec_netdev_ops;
+ ndev->ethtool_ops = &fec_enet_ethtool_ops;
+
+ writel(FEC_RX_DISABLED_IMASK, fep->hwp + FEC_IMASK);
+ netif_napi_add(ndev, &fep->napi, fec_enet_rx_napi, NAPI_POLL_WEIGHT);
+
+ if (fep->quirks & FEC_QUIRK_HAS_VLAN)
+ /* enable hw VLAN support */
+ ndev->features |= NETIF_F_HW_VLAN_CTAG_RX;
+
+ if (fep->quirks & FEC_QUIRK_HAS_CSUM) {
+ ndev->gso_max_segs = FEC_MAX_TSO_SEGS;
+
+ /* enable hw accelerator */
+ ndev->features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM
+ | NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_TSO);
+ fep->csum_flags |= FLAG_RX_CSUM_ENABLED;
+ }
+
+ if (fep->quirks & FEC_QUIRK_HAS_AVB) {
+ fep->tx_align = 0;
+ fep->rx_align = 0x3f;
+ }
+
+ ndev->hw_features = ndev->features;
+
+ fec_restart(ndev);
+
+ if (fep->quirks & FEC_QUIRK_MIB_CLEAR)
+ fec_enet_clear_ethtool_stats(ndev);
+ else
+ fec_enet_update_ethtool_stats(ndev);
+
+ return 0;
+}
+
+#ifdef CONFIG_OF
+static int fec_reset_phy(struct platform_device *pdev)
+{
+ int err, phy_reset;
+ bool active_high = false;
+ int msec = 1, phy_post_delay = 0;
+ struct device_node *np = pdev->dev.of_node;
+
+ if (!np)
+ return 0;
+
+ err = of_property_read_u32(np, "phy-reset-duration", &msec);
+ /* A sane reset duration should not be longer than 1s */
+ if (!err && msec > 1000)
+ msec = 1;
+
+ phy_reset = of_get_named_gpio(np, "phy-reset-gpios", 0);
+ if (phy_reset == -EPROBE_DEFER)
+ return phy_reset;
+ else if (!gpio_is_valid(phy_reset))
+ return 0;
+
+ err = of_property_read_u32(np, "phy-reset-post-delay", &phy_post_delay);
+ /* valid reset duration should be less than 1s */
+ if (!err && phy_post_delay > 1000)
+ return -EINVAL;
+
+ active_high = of_property_read_bool(np, "phy-reset-active-high");
+
+ err = devm_gpio_request_one(&pdev->dev, phy_reset,
+ active_high ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
+ "phy-reset");
+ if (err) {
+ dev_err(&pdev->dev, "failed to get phy-reset-gpios: %d\n", err);
+ return err;
+ }
+
+ if (msec > 20)
+ msleep(msec);
+ else
+ usleep_range(msec * 1000, msec * 1000 + 1000);
+
+ gpio_set_value_cansleep(phy_reset, !active_high);
+
+ if (!phy_post_delay)
+ return 0;
+
+ if (phy_post_delay > 20)
+ msleep(phy_post_delay);
+ else
+ usleep_range(phy_post_delay * 1000,
+ phy_post_delay * 1000 + 1000);
+
+ return 0;
+}
+#else /* CONFIG_OF */
+static int fec_reset_phy(struct platform_device *pdev)
+{
+ /*
+ * In case of platform probe, the reset has been done
+ * by machine code.
+ */
+ return 0;
+}
+#endif /* CONFIG_OF */
+
+static void
+fec_enet_get_queue_num(struct platform_device *pdev, int *num_tx, int *num_rx)
+{
+ struct device_node *np = pdev->dev.of_node;
+
+ *num_tx = *num_rx = 1;
+
+ if (!np || !of_device_is_available(np))
+ return;
+
+ /* parse the num of tx and rx queues */
+ of_property_read_u32(np, "fsl,num-tx-queues", num_tx);
+
+ of_property_read_u32(np, "fsl,num-rx-queues", num_rx);
+
+ if (*num_tx < 1 || *num_tx > FEC_ENET_MAX_TX_QS) {
+ dev_warn(&pdev->dev, "Invalid num_tx(=%d), fall back to 1\n",
+ *num_tx);
+ *num_tx = 1;
+ return;
+ }
+
+ if (*num_rx < 1 || *num_rx > FEC_ENET_MAX_RX_QS) {
+ dev_warn(&pdev->dev, "Invalid num_rx(=%d), fall back to 1\n",
+ *num_rx);
+ *num_rx = 1;
+ return;
+ }
+
+}
+
+static int fec_rt_init(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ struct rtnet_device *rtdev = &frt->dev;
+ int ret;
+
+ rtdev->open = fec_rt_open;
+ rtdev->stop = fec_rt_close;
+ rtdev->do_ioctl = fec_rt_ioctl;
+ rtdev->hard_start_xmit = fec_rt_start_xmit;
+ rtdev->get_stats = fec_rt_stats;
+ rtdev->sysbind = &fep->pdev->dev;
+
+ ret = rt_init_etherdev(rtdev, (RX_RING_SIZE + TX_RING_SIZE) * 2);
+ if (ret)
+ return ret;
+
+ rt_rtdev_connect(rtdev, &RTDEV_manager);
+ rtdev->vers = RTDEV_VERS_2_0;
+ rtdm_lock_init(&frt->lock);
+ rtdm_nrtsig_init(&frt->mdio_sig, fec_enet_mdio_done, fep);
+
+ ret = rt_register_rtnetdev(rtdev);
+ if (ret) {
+ rt_rtdev_disconnect(rtdev);
+ return ret;
+ }
+
+ rtnetif_carrier_off(rtdev);
+ frt->enabled = true;
+
+ return 0;
+}
+
+static void fec_rt_destroy(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_rt_data *frt = &fep->rtnet;
+ struct rtnet_device *rtdev = &frt->dev;
+ int i;
+
+ for (i = 0; i < fep->irqnr; i++)
+ rtdm_irq_free(&frt->irq_handle[i]);
+
+ rtdm_nrtsig_destroy(&frt->mdio_sig);
+ rt_rtdev_disconnect(rtdev);
+ rt_unregister_rtnetdev(rtdev);
+ rtdev_destroy(rtdev);
+ frt->enabled = false;
+}
+
+static int
+fec_probe(struct platform_device *pdev)
+{
+ struct fec_enet_private *fep;
+ struct fec_platform_data *pdata;
+ struct net_device *ndev;
+ int i, irq, ret = 0, eth_id;
+ struct resource *r;
+ const struct of_device_id *of_id;
+ static int dev_id;
+ struct device_node *np = pdev->dev.of_node, *phy_node;
+ int num_tx_qs;
+ int num_rx_qs;
+ bool rtnet;
+
+ fec_enet_get_queue_num(pdev, &num_tx_qs, &num_rx_qs);
+
+ /* Init network device */
+ ndev = alloc_etherdev_mqs(sizeof(struct fec_enet_private) +
+ FEC_STATS_SIZE, num_tx_qs, num_rx_qs);
+ if (!ndev)
+ return -ENOMEM;
+
+ SET_NETDEV_DEV(ndev, &pdev->dev);
+
+ /* setup board info structure */
+ fep = netdev_priv(ndev);
+ fep->pdev = pdev;
+
+ rtnet = !(rtnet_disabled || of_property_read_bool(np, "rtnet-disabled"));
+ if (rtnet) {
+ ret = fec_rt_init(ndev);
+ if (ret)
+ goto failed_rt_init;
+ }
+
+ of_id = of_match_device(fec_dt_ids, &pdev->dev);
+ if (of_id)
+ pdev->id_entry = of_id->data;
+ fep->quirks = pdev->id_entry->driver_data;
+
+ fep->netdev = ndev;
+ fep->num_rx_queues = num_rx_qs;
+ fep->num_tx_queues = num_tx_qs;
+
+#if !defined(CONFIG_M5272)
+ /* default enable pause frame auto negotiation */
+ if (fep->quirks & FEC_QUIRK_HAS_GBIT)
+ fep->pause_flag |= FEC_PAUSE_FLAG_AUTONEG;
+#endif
+
+ /* Select default pin state */
+ pinctrl_pm_select_default_state(&pdev->dev);
+
+ r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ fep->hwp = devm_ioremap_resource(&pdev->dev, r);
+ if (IS_ERR(fep->hwp)) {
+ ret = PTR_ERR(fep->hwp);
+ goto failed_ioremap;
+ }
+
+ fep->dev_id = dev_id++;
+
+ platform_set_drvdata(pdev, ndev);
+
+ if ((of_machine_is_compatible("fsl,imx6q") ||
+ of_machine_is_compatible("fsl,imx6dl")) &&
+ !of_property_read_bool(np, "fsl,err006687-workaround-present"))
+ fep->quirks |= FEC_QUIRK_ERR006687;
+
+ if (of_get_property(np, "fsl,magic-packet", NULL))
+ fep->wol_flag |= FEC_WOL_HAS_MAGIC_PACKET;
+
+ phy_node = of_parse_phandle(np, "phy-handle", 0);
+ if (!phy_node && of_phy_is_fixed_link(np)) {
+ ret = of_phy_register_fixed_link(np);
+ if (ret < 0) {
+ dev_err(&pdev->dev,
+ "broken fixed-link specification\n");
+ goto failed_phy;
+ }
+ phy_node = of_node_get(np);
+ }
+ fep->phy_node = phy_node;
+
+ ret = of_get_phy_mode(pdev->dev.of_node);
+ if (ret < 0) {
+ pdata = dev_get_platdata(&pdev->dev);
+ if (pdata)
+ fep->phy_interface = pdata->phy;
+ else
+ fep->phy_interface = PHY_INTERFACE_MODE_MII;
+ } else {
+ fep->phy_interface = ret;
+ }
+
+ fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
+ if (IS_ERR(fep->clk_ipg)) {
+ ret = PTR_ERR(fep->clk_ipg);
+ goto failed_clk;
+ }
+
+ fep->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
+ if (IS_ERR(fep->clk_ahb)) {
+ ret = PTR_ERR(fep->clk_ahb);
+ goto failed_clk;
+ }
+
+ fep->itr_clk_rate = clk_get_rate(fep->clk_ahb);
+
+ /* enet_out is optional, depends on board */
+ fep->clk_enet_out = devm_clk_get(&pdev->dev, "enet_out");
+ if (IS_ERR(fep->clk_enet_out))
+ fep->clk_enet_out = NULL;
+
+ /*
+ * We keep the companion PTP driver enabled even when
+ * operating the NIC in rt mode. The PHC is still available,
+ * although not providing rt guarantees.
+ */
+ fep->ptp_clk_on = false;
+ mutex_init(&fep->ptp_clk_mutex);
+
+ /* clk_ref is optional, depends on board */
+ fep->clk_ref = devm_clk_get(&pdev->dev, "enet_clk_ref");
+ if (IS_ERR(fep->clk_ref))
+ fep->clk_ref = NULL;
+
+ fep->bufdesc_ex = fep->quirks & FEC_QUIRK_HAS_BUFDESC_EX;
+ fep->clk_ptp = devm_clk_get(&pdev->dev, "ptp");
+ if (IS_ERR(fep->clk_ptp)) {
+ fep->clk_ptp = NULL;
+ fep->bufdesc_ex = false;
+ }
+
+ ret = fec_enet_clk_enable(ndev, true);
+ if (ret)
+ goto failed_clk;
+
+ ret = clk_prepare_enable(fep->clk_ipg);
+ if (ret)
+ goto failed_clk_ipg;
+
+ fep->reg_phy = devm_regulator_get(&pdev->dev, "phy");
+ if (!IS_ERR(fep->reg_phy)) {
+ ret = regulator_enable(fep->reg_phy);
+ if (ret) {
+ dev_err(&pdev->dev,
+ "Failed to enable phy regulator: %d\n", ret);
+ clk_disable_unprepare(fep->clk_ipg);
+ goto failed_regulator;
+ }
+ } else {
+ if (PTR_ERR(fep->reg_phy) == -EPROBE_DEFER) {
+ ret = -EPROBE_DEFER;
+ goto failed_regulator;
+ }
+ fep->reg_phy = NULL;
+ }
+
+ pm_runtime_set_autosuspend_delay(&pdev->dev, FEC_MDIO_PM_TIMEOUT);
+ pm_runtime_use_autosuspend(&pdev->dev);
+ pm_runtime_get_noresume(&pdev->dev);
+ pm_runtime_set_active(&pdev->dev);
+ pm_runtime_enable(&pdev->dev);
+
+ ret = fec_reset_phy(pdev);
+ if (ret)
+ goto failed_reset;
+
+ if (fep->bufdesc_ex)
+ fec_ptp_init(pdev);
+
+ ret = fec_enet_init(ndev);
+ if (ret)
+ goto failed_init;
+
+ for (i = 0; i < FEC_IRQ_NUM; i++) {
+ irq = platform_get_irq(pdev, i);
+ if (irq < 0) {
+ if (i)
+ break;
+ ret = irq;
+ goto failed_irq;
+ }
+ if (rtnet)
+ ret = rtdm_irq_request(&fep->rtnet.irq_handle[i], irq,
+ fec_rt_interrupt, 0, ndev->name, ndev);
+ else
+ ret = devm_request_irq(&pdev->dev, irq, fec_enet_interrupt,
+ 0, pdev->name, ndev);
+ if (ret)
+ goto failed_irq;
+
+ fep->irq[i] = irq;
+ fep->irqnr++;
+ }
+
+ init_completion(&fep->mdio_done);
+ ret = fec_enet_mii_init(pdev);
+ if (ret)
+ goto failed_mii_init;
+
+ /* Carrier starts down, phylib will bring it up */
+ netif_carrier_off(ndev);
+ fec_enet_clk_enable(ndev, false);
+ pinctrl_pm_select_sleep_state(&pdev->dev);
+
+ eth_id = of_alias_get_id(pdev->dev.of_node, "ethernet");
+ if (rtnet && eth_id >= 0)
+ sprintf(ndev->name, "rteth%d", eth_id);
+
+ ret = register_netdev(ndev);
+ if (ret)
+ goto failed_register;
+
+ netdev_info(ndev, "RTnet mode %s\n", rtnet ? "enabled" : "disabled");
+
+ device_init_wakeup(&ndev->dev, fep->wol_flag &
+ FEC_WOL_HAS_MAGIC_PACKET);
+
+ if (fep->bufdesc_ex && fep->ptp_clock)
+ netdev_info(ndev, "registered PHC device %d\n", fep->dev_id);
+
+ fep->rx_copybreak = COPYBREAK_DEFAULT;
+ INIT_WORK(&fep->tx_timeout_work, fec_enet_timeout_work);
+
+ pm_runtime_mark_last_busy(&pdev->dev);
+ pm_runtime_put_autosuspend(&pdev->dev);
+
+ return 0;
+
+failed_register:
+ fec_enet_mii_remove(fep);
+failed_mii_init:
+failed_irq:
+ if (rtnet)
+ for (i = 0; i < fep->irqnr; i++)
+ rtdm_irq_free(&fep->rtnet.irq_handle[i]);
+failed_init:
+ fec_ptp_stop(pdev);
+ if (fep->reg_phy)
+ regulator_disable(fep->reg_phy);
+failed_reset:
+ pm_runtime_put(&pdev->dev);
+ pm_runtime_disable(&pdev->dev);
+failed_regulator:
+failed_clk_ipg:
+ fec_enet_clk_enable(ndev, false);
+failed_clk:
+ if (of_phy_is_fixed_link(np))
+ of_phy_deregister_fixed_link(np);
+ of_node_put(phy_node);
+failed_phy:
+ dev_id--;
+failed_ioremap:
+ if (rtnet)
+ fec_rt_destroy(ndev);
+failed_rt_init:
+ free_netdev(ndev);
+
+ return ret;
+}
+
+static int
+fec_drv_remove(struct platform_device *pdev)
+{
+ struct net_device *ndev = platform_get_drvdata(pdev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct device_node *np = pdev->dev.of_node;
+ struct fec_rt_data *frt = &fep->rtnet;
+
+ fec_ptp_stop(pdev);
+ cancel_work_sync(&fep->tx_timeout_work);
+ if (frt->enabled)
+ fec_rt_destroy(ndev);
+ unregister_netdev(ndev);
+ fec_enet_mii_remove(fep);
+ if (fep->reg_phy)
+ regulator_disable(fep->reg_phy);
+ pm_runtime_put(&pdev->dev);
+ pm_runtime_disable(&pdev->dev);
+ if (of_phy_is_fixed_link(np))
+ of_phy_deregister_fixed_link(np);
+ of_node_put(fep->phy_node);
+ free_netdev(ndev);
+
+ return 0;
+}
+
+static int __maybe_unused fec_suspend(struct device *dev)
+{
+ struct net_device *ndev = dev_get_drvdata(dev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ rtnl_lock();
+ if (if_running(ndev)) {
+ if (fep->wol_flag & FEC_WOL_FLAG_ENABLE)
+ fep->wol_flag |= FEC_WOL_FLAG_SLEEP_ON;
+ phy_stop(ndev->phydev);
+ if_lock(ndev);
+ netif_device_detach(ndev);
+ if_tx_unlock(ndev);
+ fec_stop(ndev);
+ fec_enet_clk_enable(ndev, false);
+ if (!(fep->wol_flag & FEC_WOL_FLAG_ENABLE))
+ pinctrl_pm_select_sleep_state(&fep->pdev->dev);
+ }
+ rtnl_unlock();
+
+ if (fep->reg_phy && !(fep->wol_flag & FEC_WOL_FLAG_ENABLE))
+ regulator_disable(fep->reg_phy);
+
+ /* SOC supply clock to phy, when clock is disabled, phy link down
+ * SOC control phy regulator, when regulator is disabled, phy link down
+ */
+ if (fep->clk_enet_out || fep->reg_phy)
+ fep->link = 0;
+
+ return 0;
+}
+
+static int __maybe_unused fec_resume(struct device *dev)
+{
+ struct net_device *ndev = dev_get_drvdata(dev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
+ int ret;
+ int val;
+
+ if (fep->reg_phy && !(fep->wol_flag & FEC_WOL_FLAG_ENABLE)) {
+ ret = regulator_enable(fep->reg_phy);
+ if (ret)
+ return ret;
+ }
+
+ rtnl_lock();
+ if (if_running(ndev)) {
+ ret = fec_enet_clk_enable(ndev, true);
+ if (ret) {
+ rtnl_unlock();
+ goto failed_clk;
+ }
+ if (fep->wol_flag & FEC_WOL_FLAG_ENABLE) {
+ if (pdata && pdata->sleep_mode_enable)
+ pdata->sleep_mode_enable(false);
+ val = readl(fep->hwp + FEC_ECNTRL);
+ val &= ~(FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
+ writel(val, fep->hwp + FEC_ECNTRL);
+ fep->wol_flag &= ~FEC_WOL_FLAG_SLEEP_ON;
+ } else {
+ pinctrl_pm_select_default_state(&fep->pdev->dev);
+ }
+ fec_restart(ndev);
+ if_tx_lock(ndev);
+ netif_device_attach(ndev);
+ if_unlock(ndev);
+ phy_start(ndev->phydev);
+ }
+ rtnl_unlock();
+
+ return 0;
+
+failed_clk:
+ if (fep->reg_phy)
+ regulator_disable(fep->reg_phy);
+ return ret;
+}
+
+static int __maybe_unused fec_runtime_suspend(struct device *dev)
+{
+ struct net_device *ndev = dev_get_drvdata(dev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ clk_disable_unprepare(fep->clk_ipg);
+
+ return 0;
+}
+
+static int __maybe_unused fec_runtime_resume(struct device *dev)
+{
+ struct net_device *ndev = dev_get_drvdata(dev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ return clk_prepare_enable(fep->clk_ipg);
+}
+
+static const struct dev_pm_ops fec_pm_ops = {
+ SET_SYSTEM_SLEEP_PM_OPS(fec_suspend, fec_resume)
+ SET_RUNTIME_PM_OPS(fec_runtime_suspend, fec_runtime_resume, NULL)
+};
+
+static struct platform_driver fec_driver = {
+ .driver = {
+ .name = DRIVER_NAME,
+ .pm = &fec_pm_ops,
+ .of_match_table = fec_dt_ids,
+ },
+ .id_table = fec_devtype,
+ .probe = fec_probe,
+ .remove = fec_drv_remove,
+};
+
+module_platform_driver(fec_driver);
+
+MODULE_ALIAS("platform:"DRIVER_NAME);
+MODULE_LICENSE("GPL");
diff --git a/kernel/drivers/net/drivers/freescale/fec_ptp.c b/kernel/drivers/net/drivers/freescale/fec_ptp.c
new file mode 100644
index 000000000..6ebad3fac
--- /dev/null
+++ b/kernel/drivers/net/drivers/freescale/fec_ptp.c
@@ -0,0 +1,640 @@
+/*
+ * Fast Ethernet Controller (ENET) PTP driver for MX6x.
+ *
+ * Copyright (C) 2012 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/ptrace.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/bitops.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <linux/phy.h>
+#include <linux/fec.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_net.h>
+
+#include "fec.h"
+
+/* FEC 1588 register bits */
+#define FEC_T_CTRL_SLAVE 0x00002000
+#define FEC_T_CTRL_CAPTURE 0x00000800
+#define FEC_T_CTRL_RESTART 0x00000200
+#define FEC_T_CTRL_PERIOD_RST 0x00000030
+#define FEC_T_CTRL_PERIOD_EN 0x00000010
+#define FEC_T_CTRL_ENABLE 0x00000001
+
+#define FEC_T_INC_MASK 0x0000007f
+#define FEC_T_INC_OFFSET 0
+#define FEC_T_INC_CORR_MASK 0x00007f00
+#define FEC_T_INC_CORR_OFFSET 8
+
+#define FEC_T_CTRL_PINPER 0x00000080
+#define FEC_T_TF0_MASK 0x00000001
+#define FEC_T_TF0_OFFSET 0
+#define FEC_T_TF1_MASK 0x00000002
+#define FEC_T_TF1_OFFSET 1
+#define FEC_T_TF2_MASK 0x00000004
+#define FEC_T_TF2_OFFSET 2
+#define FEC_T_TF3_MASK 0x00000008
+#define FEC_T_TF3_OFFSET 3
+#define FEC_T_TDRE_MASK 0x00000001
+#define FEC_T_TDRE_OFFSET 0
+#define FEC_T_TMODE_MASK 0x0000003C
+#define FEC_T_TMODE_OFFSET 2
+#define FEC_T_TIE_MASK 0x00000040
+#define FEC_T_TIE_OFFSET 6
+#define FEC_T_TF_MASK 0x00000080
+#define FEC_T_TF_OFFSET 7
+
+#define FEC_ATIME_CTRL 0x400
+#define FEC_ATIME 0x404
+#define FEC_ATIME_EVT_OFFSET 0x408
+#define FEC_ATIME_EVT_PERIOD 0x40c
+#define FEC_ATIME_CORR 0x410
+#define FEC_ATIME_INC 0x414
+#define FEC_TS_TIMESTAMP 0x418
+
+#define FEC_TGSR 0x604
+#define FEC_TCSR(n) (0x608 + n * 0x08)
+#define FEC_TCCR(n) (0x60C + n * 0x08)
+#define MAX_TIMER_CHANNEL 3
+#define FEC_TMODE_TOGGLE 0x05
+#define FEC_HIGH_PULSE 0x0F
+
+#define FEC_CC_MULT (1 << 31)
+#define FEC_COUNTER_PERIOD (1 << 31)
+#define PPS_OUPUT_RELOAD_PERIOD NSEC_PER_SEC
+#define FEC_CHANNLE_0 0
+#define DEFAULT_PPS_CHANNEL FEC_CHANNLE_0
+
+/**
+ * fec_ptp_enable_pps
+ * @fep: the fec_enet_private structure handle
+ * @enable: enable the channel pps output
+ *
+ * This function enble the PPS ouput on the timer channel.
+ */
+static int fec_ptp_enable_pps(struct fec_enet_private *fep, uint enable)
+{
+ unsigned long flags;
+ u32 val, tempval;
+ int inc;
+ struct timespec64 ts;
+ u64 ns;
+ val = 0;
+
+ if (!(fep->hwts_tx_en || fep->hwts_rx_en)) {
+ dev_err(&fep->pdev->dev, "No ptp stack is running\n");
+ return -EINVAL;
+ }
+
+ if (fep->pps_enable == enable)
+ return 0;
+
+ fep->pps_channel = DEFAULT_PPS_CHANNEL;
+ fep->reload_period = PPS_OUPUT_RELOAD_PERIOD;
+ inc = fep->ptp_inc;
+
+ spin_lock_irqsave(&fep->tmreg_lock, flags);
+
+ if (enable) {
+ /* clear capture or output compare interrupt status if have.
+ */
+ writel(FEC_T_TF_MASK, fep->hwp + FEC_TCSR(fep->pps_channel));
+
+ /* It is recommended to double check the TMODE field in the
+ * TCSR register to be cleared before the first compare counter
+ * is written into TCCR register. Just add a double check.
+ */
+ val = readl(fep->hwp + FEC_TCSR(fep->pps_channel));
+ do {
+ val &= ~(FEC_T_TMODE_MASK);
+ writel(val, fep->hwp + FEC_TCSR(fep->pps_channel));
+ val = readl(fep->hwp + FEC_TCSR(fep->pps_channel));
+ } while (val & FEC_T_TMODE_MASK);
+
+ /* Dummy read counter to update the counter */
+ timecounter_read(&fep->tc);
+ /* We want to find the first compare event in the next
+ * second point. So we need to know what the ptp time
+ * is now and how many nanoseconds is ahead to get next second.
+ * The remaining nanosecond ahead before the next second would be
+ * NSEC_PER_SEC - ts.tv_nsec. Add the remaining nanoseconds
+ * to current timer would be next second.
+ */
+ tempval = readl(fep->hwp + FEC_ATIME_CTRL);
+ tempval |= FEC_T_CTRL_CAPTURE;
+ writel(tempval, fep->hwp + FEC_ATIME_CTRL);
+
+ tempval = readl(fep->hwp + FEC_ATIME);
+ /* Convert the ptp local counter to 1588 timestamp */
+ ns = timecounter_cyc2time(&fep->tc, tempval);
+ ts = ns_to_timespec64(ns);
+
+ /* The tempval is less than 3 seconds, and so val is less than
+ * 4 seconds. No overflow for 32bit calculation.
+ */
+ val = NSEC_PER_SEC - (u32)ts.tv_nsec + tempval;
+
+ /* Need to consider the situation that the current time is
+ * very close to the second point, which means NSEC_PER_SEC
+ * - ts.tv_nsec is close to be zero(For example 20ns); Since the timer
+ * is still running when we calculate the first compare event, it is
+ * possible that the remaining nanoseonds run out before the compare
+ * counter is calculated and written into TCCR register. To avoid
+ * this possibility, we will set the compare event to be the next
+ * of next second. The current setting is 31-bit timer and wrap
+ * around over 2 seconds. So it is okay to set the next of next
+ * seond for the timer.
+ */
+ val += NSEC_PER_SEC;
+
+ /* We add (2 * NSEC_PER_SEC - (u32)ts.tv_nsec) to current
+ * ptp counter, which maybe cause 32-bit wrap. Since the
+ * (NSEC_PER_SEC - (u32)ts.tv_nsec) is less than 2 second.
+ * We can ensure the wrap will not cause issue. If the offset
+ * is bigger than fep->cc.mask would be a error.
+ */
+ val &= fep->cc.mask;
+ writel(val, fep->hwp + FEC_TCCR(fep->pps_channel));
+
+ /* Calculate the second the compare event timestamp */
+ fep->next_counter = (val + fep->reload_period) & fep->cc.mask;
+
+ /* * Enable compare event when overflow */
+ val = readl(fep->hwp + FEC_ATIME_CTRL);
+ val |= FEC_T_CTRL_PINPER;
+ writel(val, fep->hwp + FEC_ATIME_CTRL);
+
+ /* Compare channel setting. */
+ val = readl(fep->hwp + FEC_TCSR(fep->pps_channel));
+ val |= (1 << FEC_T_TF_OFFSET | 1 << FEC_T_TIE_OFFSET);
+ val &= ~(1 << FEC_T_TDRE_OFFSET);
+ val &= ~(FEC_T_TMODE_MASK);
+ val |= (FEC_HIGH_PULSE << FEC_T_TMODE_OFFSET);
+ writel(val, fep->hwp + FEC_TCSR(fep->pps_channel));
+
+ /* Write the second compare event timestamp and calculate
+ * the third timestamp. Refer the TCCR register detail in the spec.
+ */
+ writel(fep->next_counter, fep->hwp + FEC_TCCR(fep->pps_channel));
+ fep->next_counter = (fep->next_counter + fep->reload_period) & fep->cc.mask;
+ } else {
+ writel(0, fep->hwp + FEC_TCSR(fep->pps_channel));
+ }
+
+ fep->pps_enable = enable;
+ spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+
+ return 0;
+}
+
+/**
+ * fec_ptp_read - read raw cycle counter (to be used by time counter)
+ * @cc: the cyclecounter structure
+ *
+ * this function reads the cyclecounter registers and is called by the
+ * cyclecounter structure used to construct a ns counter from the
+ * arbitrary fixed point registers
+ */
+static u64 fec_ptp_read(const struct cyclecounter *cc)
+{
+ struct fec_enet_private *fep =
+ container_of(cc, struct fec_enet_private, cc);
+ const struct platform_device_id *id_entry =
+ platform_get_device_id(fep->pdev);
+ u32 tempval;
+
+ tempval = readl(fep->hwp + FEC_ATIME_CTRL);
+ tempval |= FEC_T_CTRL_CAPTURE;
+ writel(tempval, fep->hwp + FEC_ATIME_CTRL);
+
+ if (id_entry->driver_data & FEC_QUIRK_BUG_CAPTURE)
+ udelay(1);
+
+ return readl(fep->hwp + FEC_ATIME);
+}
+
+/**
+ * fec_ptp_start_cyclecounter - create the cycle counter from hw
+ * @ndev: network device
+ *
+ * this function initializes the timecounter and cyclecounter
+ * structures for use in generated a ns counter from the arbitrary
+ * fixed point cycles registers in the hardware.
+ */
+void fec_ptp_start_cyclecounter(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ unsigned long flags;
+ int inc;
+
+ inc = 1000000000 / fep->cycle_speed;
+
+ /* grab the ptp lock */
+ spin_lock_irqsave(&fep->tmreg_lock, flags);
+
+ /* 1ns counter */
+ writel(inc << FEC_T_INC_OFFSET, fep->hwp + FEC_ATIME_INC);
+
+ /* use 31-bit timer counter */
+ writel(FEC_COUNTER_PERIOD, fep->hwp + FEC_ATIME_EVT_PERIOD);
+
+ writel(FEC_T_CTRL_ENABLE | FEC_T_CTRL_PERIOD_RST,
+ fep->hwp + FEC_ATIME_CTRL);
+
+ memset(&fep->cc, 0, sizeof(fep->cc));
+ fep->cc.read = fec_ptp_read;
+ fep->cc.mask = CLOCKSOURCE_MASK(31);
+ fep->cc.shift = 31;
+ fep->cc.mult = FEC_CC_MULT;
+
+ /* reset the ns time counter */
+ timecounter_init(&fep->tc, &fep->cc, ktime_to_ns(ktime_get_real()));
+
+ spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+}
+
+/**
+ * fec_ptp_adjfreq - adjust ptp cycle frequency
+ * @ptp: the ptp clock structure
+ * @ppb: parts per billion adjustment from base
+ *
+ * Adjust the frequency of the ptp cycle counter by the
+ * indicated ppb from the base frequency.
+ *
+ * Because ENET hardware frequency adjust is complex,
+ * using software method to do that.
+ */
+static int fec_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
+{
+ unsigned long flags;
+ int neg_adj = 0;
+ u32 i, tmp;
+ u32 corr_inc, corr_period;
+ u32 corr_ns;
+ u64 lhs, rhs;
+
+ struct fec_enet_private *fep =
+ container_of(ptp, struct fec_enet_private, ptp_caps);
+
+ if (ppb == 0)
+ return 0;
+
+ if (ppb < 0) {
+ ppb = -ppb;
+ neg_adj = 1;
+ }
+
+ /* In theory, corr_inc/corr_period = ppb/NSEC_PER_SEC;
+ * Try to find the corr_inc between 1 to fep->ptp_inc to
+ * meet adjustment requirement.
+ */
+ lhs = NSEC_PER_SEC;
+ rhs = (u64)ppb * (u64)fep->ptp_inc;
+ for (i = 1; i <= fep->ptp_inc; i++) {
+ if (lhs >= rhs) {
+ corr_inc = i;
+ corr_period = div_u64(lhs, rhs);
+ break;
+ }
+ lhs += NSEC_PER_SEC;
+ }
+ /* Not found? Set it to high value - double speed
+ * correct in every clock step.
+ */
+ if (i > fep->ptp_inc) {
+ corr_inc = fep->ptp_inc;
+ corr_period = 1;
+ }
+
+ if (neg_adj)
+ corr_ns = fep->ptp_inc - corr_inc;
+ else
+ corr_ns = fep->ptp_inc + corr_inc;
+
+ spin_lock_irqsave(&fep->tmreg_lock, flags);
+
+ tmp = readl(fep->hwp + FEC_ATIME_INC) & FEC_T_INC_MASK;
+ tmp |= corr_ns << FEC_T_INC_CORR_OFFSET;
+ writel(tmp, fep->hwp + FEC_ATIME_INC);
+ corr_period = corr_period > 1 ? corr_period - 1 : corr_period;
+ writel(corr_period, fep->hwp + FEC_ATIME_CORR);
+ /* dummy read to update the timer. */
+ timecounter_read(&fep->tc);
+
+ spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+
+ return 0;
+}
+
+/**
+ * fec_ptp_adjtime
+ * @ptp: the ptp clock structure
+ * @delta: offset to adjust the cycle counter by
+ *
+ * adjust the timer by resetting the timecounter structure.
+ */
+static int fec_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
+{
+ struct fec_enet_private *fep =
+ container_of(ptp, struct fec_enet_private, ptp_caps);
+ unsigned long flags;
+
+ spin_lock_irqsave(&fep->tmreg_lock, flags);
+ timecounter_adjtime(&fep->tc, delta);
+ spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+
+ return 0;
+}
+
+/**
+ * fec_ptp_gettime
+ * @ptp: the ptp clock structure
+ * @ts: timespec structure to hold the current time value
+ *
+ * read the timecounter and return the correct value on ns,
+ * after converting it into a struct timespec.
+ */
+static int fec_ptp_gettime(struct ptp_clock_info *ptp, struct timespec64 *ts)
+{
+ struct fec_enet_private *adapter =
+ container_of(ptp, struct fec_enet_private, ptp_caps);
+ u64 ns;
+ unsigned long flags;
+
+ spin_lock_irqsave(&adapter->tmreg_lock, flags);
+ ns = timecounter_read(&adapter->tc);
+ spin_unlock_irqrestore(&adapter->tmreg_lock, flags);
+
+ *ts = ns_to_timespec64(ns);
+
+ return 0;
+}
+
+/**
+ * fec_ptp_settime
+ * @ptp: the ptp clock structure
+ * @ts: the timespec containing the new time for the cycle counter
+ *
+ * reset the timecounter to use a new base value instead of the kernel
+ * wall timer value.
+ */
+static int fec_ptp_settime(struct ptp_clock_info *ptp,
+ const struct timespec64 *ts)
+{
+ struct fec_enet_private *fep =
+ container_of(ptp, struct fec_enet_private, ptp_caps);
+
+ u64 ns;
+ unsigned long flags;
+ u32 counter;
+
+ mutex_lock(&fep->ptp_clk_mutex);
+ /* Check the ptp clock */
+ if (!fep->ptp_clk_on) {
+ mutex_unlock(&fep->ptp_clk_mutex);
+ return -EINVAL;
+ }
+
+ ns = timespec64_to_ns(ts);
+ /* Get the timer value based on timestamp.
+ * Update the counter with the masked value.
+ */
+ counter = ns & fep->cc.mask;
+
+ spin_lock_irqsave(&fep->tmreg_lock, flags);
+ writel(counter, fep->hwp + FEC_ATIME);
+ timecounter_init(&fep->tc, &fep->cc, ns);
+ spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+ mutex_unlock(&fep->ptp_clk_mutex);
+ return 0;
+}
+
+/**
+ * fec_ptp_enable
+ * @ptp: the ptp clock structure
+ * @rq: the requested feature to change
+ * @on: whether to enable or disable the feature
+ *
+ */
+static int fec_ptp_enable(struct ptp_clock_info *ptp,
+ struct ptp_clock_request *rq, int on)
+{
+ struct fec_enet_private *fep =
+ container_of(ptp, struct fec_enet_private, ptp_caps);
+ int ret = 0;
+
+ if (rq->type == PTP_CLK_REQ_PPS) {
+ ret = fec_ptp_enable_pps(fep, on);
+
+ return ret;
+ }
+ return -EOPNOTSUPP;
+}
+
+/**
+ * fec_ptp_hwtstamp_ioctl - control hardware time stamping
+ * @ndev: pointer to net_device
+ * @ifreq: ioctl data
+ * @cmd: particular ioctl requested
+ */
+int fec_ptp_set(struct net_device *ndev, struct ifreq *ifr)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ struct hwtstamp_config config;
+
+ if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
+ return -EFAULT;
+
+ /* reserved for future extensions */
+ if (config.flags)
+ return -EINVAL;
+
+ switch (config.tx_type) {
+ case HWTSTAMP_TX_OFF:
+ fep->hwts_tx_en = 0;
+ break;
+ case HWTSTAMP_TX_ON:
+ fep->hwts_tx_en = 1;
+ break;
+ default:
+ return -ERANGE;
+ }
+
+ switch (config.rx_filter) {
+ case HWTSTAMP_FILTER_NONE:
+ if (fep->hwts_rx_en)
+ fep->hwts_rx_en = 0;
+ config.rx_filter = HWTSTAMP_FILTER_NONE;
+ break;
+
+ default:
+ fep->hwts_rx_en = 1;
+ config.rx_filter = HWTSTAMP_FILTER_ALL;
+ break;
+ }
+
+ return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
+ -EFAULT : 0;
+}
+
+int fec_ptp_get(struct net_device *ndev, struct ifreq *ifr)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ struct hwtstamp_config config;
+
+ config.flags = 0;
+ config.tx_type = fep->hwts_tx_en ? HWTSTAMP_TX_ON : HWTSTAMP_TX_OFF;
+ config.rx_filter = (fep->hwts_rx_en ?
+ HWTSTAMP_FILTER_ALL : HWTSTAMP_FILTER_NONE);
+
+ return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
+ -EFAULT : 0;
+}
+
+/**
+ * fec_time_keep - call timecounter_read every second to avoid timer overrun
+ * because ENET just support 32bit counter, will timeout in 4s
+ */
+static void fec_time_keep(struct work_struct *work)
+{
+ struct delayed_work *dwork = to_delayed_work(work);
+ struct fec_enet_private *fep = container_of(dwork, struct fec_enet_private, time_keep);
+ u64 ns;
+ unsigned long flags;
+
+ mutex_lock(&fep->ptp_clk_mutex);
+ if (fep->ptp_clk_on) {
+ spin_lock_irqsave(&fep->tmreg_lock, flags);
+ ns = timecounter_read(&fep->tc);
+ spin_unlock_irqrestore(&fep->tmreg_lock, flags);
+ }
+ mutex_unlock(&fep->ptp_clk_mutex);
+
+ schedule_delayed_work(&fep->time_keep, HZ);
+}
+
+/**
+ * fec_ptp_init
+ * @ndev: The FEC network adapter
+ *
+ * This function performs the required steps for enabling ptp
+ * support. If ptp support has already been loaded it simply calls the
+ * cyclecounter init routine and exits.
+ */
+
+void fec_ptp_init(struct platform_device *pdev)
+{
+ struct net_device *ndev = platform_get_drvdata(pdev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ fep->ptp_caps.owner = THIS_MODULE;
+ snprintf(fep->ptp_caps.name, 16, "fec ptp");
+
+ fep->ptp_caps.max_adj = 250000000;
+ fep->ptp_caps.n_alarm = 0;
+ fep->ptp_caps.n_ext_ts = 0;
+ fep->ptp_caps.n_per_out = 0;
+ fep->ptp_caps.n_pins = 0;
+ fep->ptp_caps.pps = 1;
+ fep->ptp_caps.adjfreq = fec_ptp_adjfreq;
+ fep->ptp_caps.adjtime = fec_ptp_adjtime;
+ fep->ptp_caps.gettime64 = fec_ptp_gettime;
+ fep->ptp_caps.settime64 = fec_ptp_settime;
+ fep->ptp_caps.enable = fec_ptp_enable;
+
+ fep->cycle_speed = clk_get_rate(fep->clk_ptp);
+ fep->ptp_inc = NSEC_PER_SEC / fep->cycle_speed;
+
+ spin_lock_init(&fep->tmreg_lock);
+
+ fec_ptp_start_cyclecounter(ndev);
+
+ INIT_DELAYED_WORK(&fep->time_keep, fec_time_keep);
+
+ fep->ptp_clock = ptp_clock_register(&fep->ptp_caps, &pdev->dev);
+ if (IS_ERR(fep->ptp_clock)) {
+ fep->ptp_clock = NULL;
+ pr_err("ptp_clock_register failed\n");
+ }
+
+ schedule_delayed_work(&fep->time_keep, HZ);
+}
+
+void fec_ptp_stop(struct platform_device *pdev)
+{
+ struct net_device *ndev = platform_get_drvdata(pdev);
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ cancel_delayed_work_sync(&fep->time_keep);
+ if (fep->ptp_clock)
+ ptp_clock_unregister(fep->ptp_clock);
+}
+
+/**
+ * fec_ptp_check_pps_event
+ * @fep: the fec_enet_private structure handle
+ *
+ * This function check the pps event and reload the timer compare counter.
+ */
+uint fec_ptp_check_pps_event(struct fec_enet_private *fep)
+{
+ u32 val;
+ u8 channel = fep->pps_channel;
+ struct ptp_clock_event event;
+
+ val = readl(fep->hwp + FEC_TCSR(channel));
+ if (val & FEC_T_TF_MASK) {
+ /* Write the next next compare(not the next according the spec)
+ * value to the register
+ */
+ writel(fep->next_counter, fep->hwp + FEC_TCCR(channel));
+ do {
+ writel(val, fep->hwp + FEC_TCSR(channel));
+ } while (readl(fep->hwp + FEC_TCSR(channel)) & FEC_T_TF_MASK);
+
+ /* Update the counter; */
+ fep->next_counter = (fep->next_counter + fep->reload_period) & fep->cc.mask;
+
+ event.type = PTP_CLOCK_PPS;
+ ptp_clock_event(fep->ptp_clock, &event);
+ return 1;
+ }
+
+ return 0;
+}
diff --git a/kernel/drivers/net/drivers/rt_fec.h b/kernel/drivers/net/drivers/rt_fec.h
deleted file mode 100644
index 2982777ea..000000000
--- a/kernel/drivers/net/drivers/rt_fec.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/****************************************************************************/
-
-/*
- * fec.h -- Fast Ethernet Controller for Motorola ColdFire SoC
- * processors.
- *
- * (C) Copyright 2000-2005, Greg Ungerer (gerg@snapgear.com)
- * (C) Copyright 2000-2001, Lineo (www.lineo.com)
- */
-
-/****************************************************************************/
-#ifndef RT_FEC_H
-#define RT_FEC_H
-/****************************************************************************/
-
-#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
- defined(CONFIG_M520x) || defined(CONFIG_M532x) || \
- defined(CONFIG_ARCH_MXC) || defined(CONFIG_SOC_IMX28)
-/*
- * Just figures, Motorola would have to change the offsets for
- * registers in the same peripheral device on different models
- * of the ColdFire!
- */
-#define FEC_IEVENT 0x004 /* Interrupt event reg */
-#define FEC_IMASK 0x008 /* Interrupt mask reg */
-#define FEC_R_DES_ACTIVE 0x010 /* Receive descriptor reg */
-#define FEC_X_DES_ACTIVE 0x014 /* Transmit descriptor reg */
-#define FEC_ECNTRL 0x024 /* Ethernet control reg */
-#define FEC_MII_DATA 0x040 /* MII manage frame reg */
-#define FEC_MII_SPEED 0x044 /* MII speed control reg */
-#define FEC_MIB_CTRLSTAT 0x064 /* MIB control/status reg */
-#define FEC_R_CNTRL 0x084 /* Receive control reg */
-#define FEC_X_CNTRL 0x0c4 /* Transmit Control reg */
-#define FEC_ADDR_LOW 0x0e4 /* Low 32bits MAC address */
-#define FEC_ADDR_HIGH 0x0e8 /* High 16bits MAC address */
-#define FEC_OPD 0x0ec /* Opcode + Pause duration */
-#define FEC_HASH_TABLE_HIGH 0x118 /* High 32bits hash table */
-#define FEC_HASH_TABLE_LOW 0x11c /* Low 32bits hash table */
-#define FEC_GRP_HASH_TABLE_HIGH 0x120 /* High 32bits hash table */
-#define FEC_GRP_HASH_TABLE_LOW 0x124 /* Low 32bits hash table */
-#define FEC_X_WMRK 0x144 /* FIFO transmit water mark */
-#define FEC_R_BOUND 0x14c /* FIFO receive bound reg */
-#define FEC_R_FSTART 0x150 /* FIFO receive start reg */
-#define FEC_R_DES_START 0x180 /* Receive descriptor ring */
-#define FEC_X_DES_START 0x184 /* Transmit descriptor ring */
-#define FEC_R_BUFF_SIZE 0x188 /* Maximum receive buff size */
-#define FEC_TACC 0x1c0 /* Transmit accelerator reg */
-#define FEC_MIIGSK_CFGR 0x300 /* MIIGSK Configuration reg */
-#define FEC_MIIGSK_ENR 0x308 /* MIIGSK Enable reg */
-
-#define BM_MIIGSK_CFGR_MII 0x00
-#define BM_MIIGSK_CFGR_RMII 0x01
-#define BM_MIIGSK_CFGR_FRCONT_10M 0x40
-
-#else
-
-#define FEC_ECNTRL 0x000 /* Ethernet control reg */
-#define FEC_IEVENT 0x004 /* Interrupt even reg */
-#define FEC_IMASK 0x008 /* Interrupt mask reg */
-#define FEC_IVEC 0x00c /* Interrupt vec status reg */
-#define FEC_R_DES_ACTIVE 0x010 /* Receive descriptor reg */
-#define FEC_X_DES_ACTIVE 0x014 /* Transmit descriptor reg */
-#define FEC_MII_DATA 0x040 /* MII manage frame reg */
-#define FEC_MII_SPEED 0x044 /* MII speed control reg */
-#define FEC_R_BOUND 0x08c /* FIFO receive bound reg */
-#define FEC_R_FSTART 0x090 /* FIFO receive start reg */
-#define FEC_X_WMRK 0x0a4 /* FIFO transmit water mark */
-#define FEC_X_FSTART 0x0ac /* FIFO transmit start reg */
-#define FEC_R_CNTRL 0x104 /* Receive control reg */
-#define FEC_MAX_FRM_LEN 0x108 /* Maximum frame length reg */
-#define FEC_X_CNTRL 0x144 /* Transmit Control reg */
-#define FEC_ADDR_LOW 0x3c0 /* Low 32bits MAC address */
-#define FEC_ADDR_HIGH 0x3c4 /* High 16bits MAC address */
-#define FEC_GRP_HASH_TABLE_HIGH 0x3c8 /* High 32bits hash table */
-#define FEC_GRP_HASH_TABLE_LOW 0x3cc /* Low 32bits hash table */
-#define FEC_R_DES_START 0x3d0 /* Receive descriptor ring */
-#define FEC_X_DES_START 0x3d4 /* Transmit descriptor ring */
-#define FEC_R_BUFF_SIZE 0x3d8 /* Maximum receive buff size */
-#define FEC_FIFO_RAM 0x400 /* FIFO RAM buffer */
-
-#endif /* CONFIG_M5272 */
-
-
-/*
- * Define the buffer descriptor structure.
- */
-#if defined(CONFIG_ARCH_MXC) || defined(CONFIG_SOC_IMX28)
-struct bufdesc {
- unsigned short cbd_datlen; /* Data length */
- unsigned short cbd_sc; /* Control and status info */
- unsigned long cbd_bufaddr; /* Buffer address */
-};
-#else
-struct bufdesc {
- unsigned short cbd_sc; /* Control and status info */
- unsigned short cbd_datlen; /* Data length */
- unsigned long cbd_bufaddr; /* Buffer address */
-};
-#endif
-
-/*
- * The following definitions courtesy of commproc.h, which where
- * Copyright (c) 1997 Dan Malek (dmalek@jlc.net).
- */
-#define BD_SC_EMPTY ((ushort)0x8000) /* Receive is empty */
-#define BD_SC_READY ((ushort)0x8000) /* Transmit is ready */
-#define BD_SC_WRAP ((ushort)0x2000) /* Last buffer descriptor */
-#define BD_SC_INTRPT ((ushort)0x1000) /* Interrupt on change */
-#define BD_SC_CM ((ushort)0x0200) /* Continuous mode */
-#define BD_SC_ID ((ushort)0x0100) /* Rec'd too many idles */
-#define BD_SC_P ((ushort)0x0100) /* xmt preamble */
-#define BD_SC_BR ((ushort)0x0020) /* Break received */
-#define BD_SC_FR ((ushort)0x0010) /* Framing error */
-#define BD_SC_PR ((ushort)0x0008) /* Parity error */
-#define BD_SC_OV ((ushort)0x0002) /* Overrun */
-#define BD_SC_CD ((ushort)0x0001) /* ?? */
-
-/* Buffer descriptor control/status used by Ethernet receive.
-*/
-#define BD_ENET_RX_EMPTY ((ushort)0x8000)
-#define BD_ENET_RX_WRAP ((ushort)0x2000)
-#define BD_ENET_RX_INTR ((ushort)0x1000)
-#define BD_ENET_RX_LAST ((ushort)0x0800)
-#define BD_ENET_RX_FIRST ((ushort)0x0400)
-#define BD_ENET_RX_MISS ((ushort)0x0100)
-#define BD_ENET_RX_LG ((ushort)0x0020)
-#define BD_ENET_RX_NO ((ushort)0x0010)
-#define BD_ENET_RX_SH ((ushort)0x0008)
-#define BD_ENET_RX_CR ((ushort)0x0004)
-#define BD_ENET_RX_OV ((ushort)0x0002)
-#define BD_ENET_RX_CL ((ushort)0x0001)
-#define BD_ENET_RX_STATS ((ushort)0x013f) /* All status bits */
-
-/* Buffer descriptor control/status used by Ethernet transmit.
-*/
-#define BD_ENET_TX_READY ((ushort)0x8000)
-#define BD_ENET_TX_PAD ((ushort)0x4000)
-#define BD_ENET_TX_WRAP ((ushort)0x2000)
-#define BD_ENET_TX_INTR ((ushort)0x1000)
-#define BD_ENET_TX_LAST ((ushort)0x0800)
-#define BD_ENET_TX_TC ((ushort)0x0400)
-#define BD_ENET_TX_DEF ((ushort)0x0200)
-#define BD_ENET_TX_HB ((ushort)0x0100)
-#define BD_ENET_TX_LC ((ushort)0x0080)
-#define BD_ENET_TX_RL ((ushort)0x0040)
-#define BD_ENET_TX_RCMASK ((ushort)0x003c)
-#define BD_ENET_TX_UN ((ushort)0x0002)
-#define BD_ENET_TX_CSL ((ushort)0x0001)
-#define BD_ENET_TX_STATS ((ushort)0x03ff) /* All status bits */
-
-
-/****************************************************************************/
-#endif /* RT_FEC_H */
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 21/31] net/drivers: fec: enable multicast
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (19 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 20/31] net/drivers: fec: rebase over original driver from kernel 4.14.85 Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 22/31] demo: restrict net/ to cobalt build Jean-Baptiste Trédez
` (11 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
.../drivers/net/drivers/freescale/fec_main.c | 60 +++++++++++++++++++
1 file changed, 60 insertions(+)
diff --git a/kernel/drivers/net/drivers/freescale/fec_main.c b/kernel/drivers/net/drivers/freescale/fec_main.c
index 08956dfab..41c2fb1da 100644
--- a/kernel/drivers/net/drivers/freescale/fec_main.c
+++ b/kernel/drivers/net/drivers/freescale/fec_main.c
@@ -3608,6 +3608,65 @@ static void set_multicast_list(struct net_device *ndev)
writel(hash_low, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
}
+static void fec_rt_set_multicast_list(struct rtnet_device *rtdev)
+{
+ struct fec_enet_private *fep;
+ unsigned int i, bit, data, crc, tmp;
+ unsigned char hash;
+ unsigned int hash_high = 0, hash_low = 0;
+ struct rtdev_mc_list *mca;
+
+ fep = container_of(rtdev, struct fec_enet_private, rtnet.dev);
+
+ if (rtdev->flags & IFF_PROMISC) {
+ tmp = readl(fep->hwp + FEC_R_CNTRL);
+ tmp |= 0x8;
+ writel(tmp, fep->hwp + FEC_R_CNTRL);
+ return;
+ }
+
+ tmp = readl(fep->hwp + FEC_R_CNTRL);
+ tmp &= ~0x8;
+ writel(tmp, fep->hwp + FEC_R_CNTRL);
+
+ if (rtdev->flags & IFF_ALLMULTI) {
+ /* Catch all multicast addresses, so set the
+ * filter to all 1's
+ */
+ writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+ writel(0xffffffff, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+
+ return;
+ }
+
+ /* Add the addresses in hash register */
+ for (mca = rtdev->mc_list; mca; mca = mca->next) {
+ /* calculate crc32 value of mac address */
+ crc = 0xffffffff;
+
+ for (i = 0; i < mca->dmi_addrlen; i++) {
+ data = mca->dmi_addr[i];
+ for (bit = 0; bit < 8; bit++, data >>= 1) {
+ crc = (crc >> 1) ^
+ (((crc ^ data) & 1) ? CRC32_POLY : 0);
+ }
+ }
+
+ /* only upper 6 bits (FEC_HASH_BITS) are used
+ * which point to specific bit in the hash registers
+ */
+ hash = (crc >> (32 - FEC_HASH_BITS)) & 0x3f;
+
+ if (hash > 31)
+ hash_high |= 1 << (hash - 32);
+ else
+ hash_low |= 1 << hash;
+ }
+
+ writel(hash_high, fep->hwp + FEC_GRP_HASH_TABLE_HIGH);
+ writel(hash_low, fep->hwp + FEC_GRP_HASH_TABLE_LOW);
+}
+
/* Set a MAC change in hardware. */
static int
fec_set_mac_address(struct net_device *ndev, void *p)
@@ -3945,6 +4004,7 @@ static int fec_rt_init(struct net_device *ndev)
rtdev->do_ioctl = fec_rt_ioctl;
rtdev->hard_start_xmit = fec_rt_start_xmit;
rtdev->get_stats = fec_rt_stats;
+ rtdev->set_multicast_list = fec_rt_set_multicast_list;
rtdev->sysbind = &fep->pdev->dev;
ret = rt_init_etherdev(rtdev, (RX_RING_SIZE + TX_RING_SIZE) * 2);
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 22/31] demo: restrict net/ to cobalt build
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (20 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 21/31] net/drivers: fec: enable multicast Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 23/31] net/ipv4: route: fix counting of allocated net routes Jean-Baptiste Trédez
` (10 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
demo/Makefile.am | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/demo/Makefile.am b/demo/Makefile.am
index 2839d074b..0c4caa5c0 100644
--- a/demo/Makefile.am
+++ b/demo/Makefile.am
@@ -1,2 +1,6 @@
-SUBDIRS = posix alchemy net
+SUBDIRS = posix alchemy
+
+if XENO_COBALT
+SUBDIRS += net
+endif
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 23/31] net/ipv4: route: fix counting of allocated net routes
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (21 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 22/31] demo: restrict net/ to cobalt build Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 24/31] net/ipv4: route: handle default net route Jean-Baptiste Trédez
` (9 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/ipv4/route.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/drivers/net/stack/ipv4/route.c b/kernel/drivers/net/stack/ipv4/route.c
index d9a9c8b9b..14a8b2932 100644
--- a/kernel/drivers/net/stack/ipv4/route.c
+++ b/kernel/drivers/net/stack/ipv4/route.c
@@ -745,7 +745,7 @@ static inline void rt_free_net_route(struct net_route *rt)
{
rt->next = free_net_route;
free_net_route = rt;
- allocated_host_routes--;
+ allocated_net_routes--;
}
/***
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 24/31] net/ipv4: route: handle default net route
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (22 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 23/31] net/ipv4: route: fix counting of allocated net routes Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 25/31] utils/net: rtroute: add/del default route Jean-Baptiste Trédez
` (8 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/doc/README.routing | 22 ++++++++++
kernel/drivers/net/doc/README.rtnetproxy | 6 ++-
kernel/drivers/net/stack/ipv4/route.c | 54 +++++++++++++++++++++---
3 files changed, 75 insertions(+), 7 deletions(-)
diff --git a/kernel/drivers/net/doc/README.routing b/kernel/drivers/net/doc/README.routing
index f59c3f3f5..674039f91 100644
--- a/kernel/drivers/net/doc/README.routing
+++ b/kernel/drivers/net/doc/README.routing
@@ -115,3 +115,25 @@ the hash-key-based lookup and a potential query of the key-less list of routes.
RTnet provides by default a pool of 16 network routes. This number can be
modified in the source code (see ipv4/route.c). Network routes are only
manually added or removed via rtroute.
+
+4. Default gateway address
+--------------------------
+
+In some cases, it is desirable for the RTnet routing system to fall
+back to a default gateway address for otherwise unresolved
+routes. Typically, such a gateway comes in handy when a rtnetproxy
+device is required for sharing a single physical interface (NIC)
+between the real-time and regular traffic (accepting the implications
+this may have with respect to real-time performance). Both the regular
+and the RTnet routing configurations can define their respective
+default gateway, first to route regular traffic to the proxy, next to
+route such traffic via the gateway assigned to the default RTnet
+route.
+
+A default gateway can be defined by the rtroute command as follows:
+
+# rtroute add default gw <IP_ADDRESS>
+
+Support for the default gateway is available when
+CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING is enabled. A single default
+gateway address is supported.
diff --git a/kernel/drivers/net/doc/README.rtnetproxy b/kernel/drivers/net/doc/README.rtnetproxy
index 647cdb6a9..7d115bbca 100644
--- a/kernel/drivers/net/doc/README.rtnetproxy
+++ b/kernel/drivers/net/doc/README.rtnetproxy
@@ -14,8 +14,10 @@ the network device is "rtproxy".
Setup:
--------
-Get your RTnet working first! All IP addresses you are interested in have
-to be set via "rtifconfig ethX route solicit IP_ADDRESS"!
+Get your RTnet working first! All IP addresses you are interested in
+have to be set via "rtifconfig ethX route solicit IP_ADDRESS", or a
+default gateway machine should have been set via "rtroute add default
+gw IP_ADDRESS".
insmod rtnetproxy.o
diff --git a/kernel/drivers/net/stack/ipv4/route.c b/kernel/drivers/net/stack/ipv4/route.c
index 14a8b2932..e352e39fe 100644
--- a/kernel/drivers/net/stack/ipv4/route.c
+++ b/kernel/drivers/net/stack/ipv4/route.c
@@ -51,7 +51,7 @@ struct net_route {
u32 gw_ip;
};
-#if (CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES & \
+#if (CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES & \
(CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES - 1))
#error CONFIG_XENO_DRIVERS_NET_RTIPV4_HOST_ROUTES must be power of 2
#endif
@@ -88,6 +88,7 @@ static struct net_route *free_net_route;
static int allocated_net_routes;
static struct net_route *net_hash_tbl[NET_HASH_TBL_SIZE + 1];
static unsigned int net_hash_key_shift = NET_HASH_KEY_SHIFT;
+static u32 default_gw_ip;
static DEFINE_RTDM_LOCK(net_table_lock);
module_param(net_hash_key_shift, uint, 0444);
@@ -376,7 +377,15 @@ static int rtnet_ipv4_net_route_next(struct xnvfile_snapshot_iterator *it,
struct rtnet_ipv4_net_route_data *p = data;
if (priv->entry_ptr == NULL) {
- if (++priv->key >= NET_HASH_TBL_SIZE + 1)
+ if (++priv->key == 0 && default_gw_ip != INADDR_ANY) {
+ p->key = NET_HASH_TBL_SIZE;
+ p->dest_net_ip = INADDR_ANY;
+ p->dest_net_mask = INADDR_ANY;
+ p->gw_ip = default_gw_ip;
+ return 1;
+ }
+
+ if (priv->key >= NET_HASH_TBL_SIZE + 1)
return 0;
priv->entry_ptr = net_hash_tbl[priv->key];
@@ -410,12 +419,16 @@ static int rtnet_ipv4_net_route_show(struct xnvfile_snapshot_iterator *it,
"\t\t%u.%u.%u.%-3u\n",
p->key, NIPQUAD(p->dest_net_ip),
NIPQUAD(p->dest_net_mask), NIPQUAD(p->gw_ip));
- else
+ else if (p->dest_net_ip != INADDR_ANY)
xnvfile_printf(it,
"*\t%u.%u.%u.%-3u\t%u.%u.%u.%-3u\t\t"
"%u.%u.%u.%-3u\n",
NIPQUAD(p->dest_net_ip),
NIPQUAD(p->dest_net_mask), NIPQUAD(p->gw_ip));
+ else
+ xnvfile_printf(it,
+ "*\t%-11s\t0.0.0.0\t\t\t%u.%u.%u.%-3u\n",
+ "default", NIPQUAD(p->gw_ip));
return 0;
}
@@ -760,6 +773,17 @@ int rt_ip_route_add_net(u32 addr, u32 mask, u32 gw_addr)
unsigned int key;
u32 shifted_mask;
+ rtdm_lock_get_irqsave(&net_table_lock, context);
+
+ if (addr == INADDR_ANY) {
+ default_gw_ip = gw_addr;
+ allocated_net_routes++;
+ rtdm_lock_put_irqrestore(&net_table_lock, context);
+ return 0;
+ }
+
+ rtdm_lock_put_irqrestore(&net_table_lock, context);
+
addr &= mask;
if ((new_route = rt_alloc_net_route()) != NULL) {
@@ -823,6 +847,17 @@ int rt_ip_route_del_net(u32 addr, u32 mask)
unsigned int key;
u32 shifted_mask;
+ rtdm_lock_get_irqsave(&net_table_lock, context);
+
+ if (addr == INADDR_ANY) {
+ default_gw_ip = INADDR_ANY;
+ allocated_net_routes--;
+ rtdm_lock_put_irqrestore(&net_table_lock, context);
+ return 0;
+ }
+
+ rtdm_lock_put_irqrestore(&net_table_lock, context);
+
addr &= mask;
shifted_mask = NET_HASH_KEY_MASK << net_hash_key_shift;
@@ -856,6 +891,7 @@ int rt_ip_route_del_net(u32 addr, u32 mask)
return -ENOENT;
}
+
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */
/***
@@ -915,8 +951,9 @@ restart:
else
while (host_rt != NULL) {
if ((host_rt->dest_host.ip == daddr) &&
- (host_rt->dest_host.rtdev->local_ip == saddr))
+ (host_rt->dest_host.rtdev->local_ip == saddr)) {
goto host_route_found;
+ }
host_rt = host_rt->next;
}
@@ -947,7 +984,7 @@ restart:
rtdm_lock_put_irqrestore(&net_table_lock, context);
- /* last try: no hash key */
+ /* no hash key */
rtdm_lock_get_irqsave(&net_table_lock, context);
net_rt = net_hash_tbl[NET_HASH_TBL_SIZE];
@@ -966,6 +1003,13 @@ restart:
net_rt = net_rt->next;
}
+ /* last try: use default route if any. */
+ if (default_gw_ip != INADDR_ANY) {
+ daddr = default_gw_ip;
+ rtdm_lock_put_irqrestore(&net_table_lock, context);
+ goto restart;
+ }
+
rtdm_lock_put_irqrestore(&net_table_lock, context);
}
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4_NETROUTING */
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 25/31] utils/net: rtroute: add/del default route
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (23 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 24/31] net/ipv4: route: handle default net route Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 26/31] net/ipv4: sock: handle SO_REUSEADDR for SOCK_DGRAM gracefully Jean-Baptiste Trédez
` (7 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
utils/net/rtroute.c | 39 ++++++++++++++++++++++++++++++++-------
1 file changed, 32 insertions(+), 7 deletions(-)
diff --git a/utils/net/rtroute.c b/utils/net/rtroute.c
index ef6b56ecf..42d526f9e 100644
--- a/utils/net/rtroute.c
+++ b/utils/net/rtroute.c
@@ -24,6 +24,7 @@
#include <errno.h>
#include <fcntl.h>
+#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -37,9 +38,10 @@
#include <ipv4_chrdev.h>
-int f;
-struct ipv4_cmd cmd;
-struct in_addr addr;
+static int f;
+static struct ipv4_cmd cmd;
+static struct in_addr addr;
+static bool default_route;
/* help gcc a bit... */
@@ -52,8 +54,10 @@ void help(void)
"\trtroute solicit <addr> dev <dev>\n"
"\trtroute add <addr> <hwaddr> dev <dev>\n"
"\trtroute add <addr> netmask <mask> gw <gw-addr>\n"
+ "\trtroute add default gw <gw-addr>\n"
"\trtroute del <addr> [dev <dev>]\n"
"\trtroute del <addr> netmask <mask>\n"
+ "\trtroute del default gw\n"
"\trtroute get <addr> [dev <dev>]\n"
"\trtroute -f <host-routes-file>\n"
);
@@ -130,7 +134,18 @@ void route_add(int argc, char *argv[])
int ret;
- if (argc == 6) {
+ if (default_route) {
+ /*** add default route ***/
+ if (argc != 5 || strcmp(argv[3], "gw") != 0)
+ help();
+
+ cmd.args.addnet.gw_addr = INADDR_ANY;
+ cmd.args.addnet.net_mask = INADDR_ANY;
+ if (!inet_aton(argv[4], &addr))
+ help();
+ cmd.args.addnet.gw_addr = addr.s_addr;
+ ret = ioctl(f, IOC_RT_NET_ROUTE_ADD, &cmd);
+ } else if (argc == 6) {
/*** add host route ***/
if ((ether_aton_r(argv[3], &dev_addr) == NULL) ||
(strcmp(argv[4], "dev") != 0))
@@ -271,7 +286,15 @@ void route_delete(int argc, char *argv[])
int ret;
- if (argc == 3) {
+ if (default_route) {
+ /*** delete default route ***/
+ if (argc != 4 || strcmp(argv[3], "gw") != 0)
+ help();
+
+ cmd.args.delnet.net_addr = INADDR_ANY;
+ cmd.args.delnet.net_mask = INADDR_ANY;
+ ret = ioctl(f, IOC_RT_NET_ROUTE_DELETE, &cmd);
+ } else if (argc == 3) {
/*** delete host route ***/
cmd.args.delhost.ip_addr = addr.s_addr;
@@ -374,8 +397,10 @@ int main(int argc, char *argv[])
if (strcmp(argv[1], "-f") == 0)
route_listadd(argv[2]);
- /* second argument is now always an IP address */
- if (!inet_aton(argv[2], &addr))
+ /* second argument is now either 'default' (for a gw) or an IP
+ address */
+ default_route = !strcmp(argv[2], "default");
+ if (!default_route && !inet_aton(argv[2], &addr))
help();
if (strcmp(argv[1], "solicit") == 0)
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 26/31] net/ipv4: sock: handle SO_REUSEADDR for SOCK_DGRAM gracefully
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (24 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 25/31] utils/net: rtroute: add/del default route Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 27/31] net/stack: igmp: resolve default multicast interface Jean-Baptiste Trédez
` (6 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
Issuing SO_REUSEADDR for an IP socket before binding it is part of the
boilerplate code of many applications. Handle such request gracefully
like the regular network stack does, returning success without
performing any action since we implement no timed wait state for
SOCK_DGRAM.
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/ipv4/ip_sock.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/kernel/drivers/net/stack/ipv4/ip_sock.c b/kernel/drivers/net/stack/ipv4/ip_sock.c
index 0349ed1b1..a3f7d1f57 100644
--- a/kernel/drivers/net/stack/ipv4/ip_sock.c
+++ b/kernel/drivers/net/stack/ipv4/ip_sock.c
@@ -35,6 +35,9 @@ int rt_ip_setsockopt(struct rtdm_fd *fd, struct rtsocket *s, int level,
int err = 0;
unsigned int _tos, *tos;
+ if (level == SOL_SOCKET && optname == SO_REUSEADDR)
+ return 0;
+
if (level != SOL_IP)
return -ENOPROTOOPT;
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 27/31] net/stack: igmp: resolve default multicast interface
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (25 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 26/31] net/ipv4: sock: handle SO_REUSEADDR for SOCK_DGRAM gracefully Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 28/31] net/drivers: fec: update from linux kernel 5.4 and NXP I.MX8 Jean-Baptiste Trédez
` (5 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: Philippe Gerum <rpm@xenomai.org>
If INADDR_ANY is passed as the imr_interface address, attempt to
resolve the default multicast interface by finding a route to the
multicast address.
Signed-off-by: Philippe Gerum <rpm@xenomai.org>
---
kernel/drivers/net/stack/ipv4/igmp.c | 14 +++++++++++---
1 file changed, 11 insertions(+), 3 deletions(-)
diff --git a/kernel/drivers/net/stack/ipv4/igmp.c b/kernel/drivers/net/stack/ipv4/igmp.c
index 9568cedc7..cd193d699 100644
--- a/kernel/drivers/net/stack/ipv4/igmp.c
+++ b/kernel/drivers/net/stack/ipv4/igmp.c
@@ -342,9 +342,17 @@ void rt_ip_mc_dec_group(struct rtnet_device *rtdev, u32 addr)
static struct rtnet_device *rt_ip_mc_find_dev(const struct ip_mreq *imr)
{
struct rtnet_device *rtdev = NULL;
-
- if (imr->imr_interface.s_addr)
- rtdev = rt_ip_dev_find(imr->imr_interface.s_addr);
+ struct dest_route rt;
+ int ret;
+
+ if (imr->imr_interface.s_addr != INADDR_ANY) {
+ rtdev = rt_ip_dev_find(imr->imr_interface.s_addr);
+ } else {
+ ret = rt_ip_route_output(&rt, imr->imr_multiaddr.s_addr,
+ INADDR_ANY);
+ if (!ret)
+ rtdev = rt.rtdev;
+ }
return rtdev;
}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 28/31] net/drivers: fec: update from linux kernel 5.4 and NXP I.MX8
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (26 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 27/31] net/stack: igmp: resolve default multicast interface Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 29/31] Kconfig : enable fec for ARM64 build Jean-Baptiste Trédez
` (4 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
Signed-off-by: Jean-Baptiste Trédez <jean-baptiste.tredez@alstefgroup.com>
----------------------------------------
Content :
net: fec: add phy_reset_after_clk_enable() support
Some PHYs (for example the SMSC LAN8710/LAN8720) doesn't allow turning
the refclk on and off again during operation (according to their
datasheet). Nonetheless exactly this behaviour was introduced for power
saving reasons by commit e8fcfcd5684a ("net: fec: optimize the clock management to save power").
Therefore add support for the phy_reset_after_clk_enable function from
phylib to mitigate this issue.
Generally speaking this issue is only relevant if the ref clk for the
PHY is generated by the SoC and therefore the PHY is configured to
"REF_CLK In Mode". In our specific case (PCB) this problem does occur at
about every 10th to 50th POR of an LAN8710 connected to an i.MX6SOLO
SoC. The typical symptom of this problem is a "swinging" ethernet link.
Similar issues were reported by users of the NXP forum:
https://community.nxp.com/thread/389902
https://community.nxp.com/message/309354
With this patch applied the issue didn't occur for at least a few
hundret PORs of our board.
Fixes: e8fcfcd5684a ("net: fec: optimize the clock management to save power")
Signed-off-by: Richard Leitner <richard.leitner@skidata.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: add necessary defines to work on ARM64
The i.MX8 is a ARMv8 based SoC, that uses the same FEC IP as the
earlier, ARMv7 based, i.MX SoCs. Allow the driver to work on ARM64.
Signed-off-by: Lucas Stach <l.stach@pengutronix.de>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
drivers: net: Remove device_node checks with of_mdiobus_register()
A number of drivers have the following pattern:
if (np)
of_mdiobus_register()
else
mdiobus_register()
which the implementation of of_mdiobus_register() now takes care of.
Remove that pattern in drivers that strictly adhere to it.
Signed-off-by: Florian Fainelli <f.fainelli@gmail.com>
Reviewed-by: Grygorii Strashko <grygorii.strashko@ti.com>
Reviewed-by: Fugang Duan <fugang.duan@nxp.com>
Reviewed-by: Antoine Tenart <antoine.tenart@bootlin.com>
Reviewed-by: Jose Abreu <joabreu@synopsys.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: freescale: Allow FEC with COMPILE_TEST
The Freescale FEC driver builds fine with COMPILE_TEST, so make that
possible.
Signed-off-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: Add a SPDX identifier
Currently there is no license information in the header of
this file.
The MODULE_LICENSE field contains ("GPL"), which means
GNU Public License v2 or later, so add a corresponding
SPDX license identifier.
Signed-off-by: Fabio Estevam <fabio.estevam@nxp.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: freescale: Use generic CRC32 implementation
Use generic kernel CRC32 implementation because it:
1. Should be faster (uses lookup tables),
2. Removes duplicated CRC generation code,
3. Uses well-proven algorithm instead of coding it one more time.
Suggested-by: Eric Biggers <ebiggers3@gmail.com>
Signed-off-by: Krzysztof Kozlowski <krzk@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: check DMA addressing limitations
Check DMA addressing limitations as suggested by the DMA API
how-to. This does not fix a particular issue seen but is
considered good style.
Signed-off-by: Stefan Agner <stefan@agner.ch>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Reviewed-by: Robin Murphy <robin.murphy@arm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: Use phy_set_max_speed() to limit advertised speed
Many Ethernet MAC drivers want to limit the PHY to only advertise a
maximum speed of 100Mbs or 1Gbps. Rather than using a mask, make use
of the helper function phy_set_max_speed().
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: Add helper to remove a supported link mode
Some MAC hardware cannot support a subset of link modes. e.g. often
1Gbps Full duplex is supported, but Half duplex is not. Add a helper
to remove such a link mode.
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: Add helper for MACs which support pause
Rather than have the MAC drivers manipulate phydev members, add a
helper function for MACs supporting Pause, but not Asym Pause.
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: Add helper for set_pauseparam for Pause
ethtool can be used to enable/disable pause. Add a helper to configure
the PHY when Pause is supported.
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: remove redundant null pointer check before of_node_put
of_node_put has taken the null pointer check into account. So it is
safe to remove the duplicated check before of_node_put.
Signed-off-by: zhong jiang <zhongjiang@huawei.com>
Reviewed-by: Vladimir Zapolskiy <vz@mleia.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: don't dump RX FIFO register when not available
Commit db65f35f50e0 ("net: fec: add support of ethtool get_regs") introduce
ethool "--register-dump" interface to dump all FEC registers.
But not all silicon implementations of the Freescale FEC hardware module
have the FRBR (FIFO Receive Bound Register) and FRSR (FIFO Receive Start
Register) register, so we should not be trying to dump them on those that
don't.
To fix it we create a quirk flag, FEC_QUIRK_HAS_RFREG, and check it before
dump those RX FIFO registers.
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: get regulator optional
According to the device tree binding the phy-supply property is
optional. Use the regulator_get_optional API accordingly. The
code already handles NULL just fine.
This gets rid of the following warning:
fec 2188000.ethernet: 2188000.ethernet supply phy not found, using dummy regulator
Signed-off-by: Stefan Agner <stefan@agner.ch>
Reviewed-by: Marcel Ziswiler <marcel.ziswiler@toradex.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: freescale: set FEC ethtool regs version
Currently the ethtool_regs version is set to 0 for FEC devices.
Use this field to store the register dump version exposed by the
kernel. The choosen version 2 corresponds to the kernel compile test:
#if defined(CONFIG_M523x) || defined(CONFIG_M527x)
|| defined(CONFIG_M528x) || defined(CONFIG_M520x)
|| defined(CONFIG_M532x) || defined(CONFIG_ARM)
|| defined(CONFIG_ARM64) || defined(CONFIG_COMPILE_TEST)
and version 1 corresponds to the opposite. Binaries of ethtool unaware
of this version will dump the whole set as usual.
Signed-off-by: Vivien Didelot <vivien.didelot@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: manage ahb clock in runtime pm
Some SOC like i.MX6SX clock have some limits:
- ahb clock should be disabled before ipg.
- ahb and ipg clocks are required for MAC MII bus.
So, move the ahb clock to runtime management together with
ipg clock.
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: support of_get_mac_address new ERR_PTR error
There was NVMEM support added to of_get_mac_address, so it could now
return ERR_PTR encoded error values, so we need to adjust all current
users of of_get_mac_address to this new fact.
While at it, remove superfluous is_valid_ether_addr as the MAC address
returned from of_get_mac_address is always valid and checked by
is_valid_ether_addr anyway.
Fixes: d01f449c008a ("of_net: add NVMEM support to of_get_mac_address")
Signed-off-by: Petr Štetiar <ynezz@true.cz>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: remove redundant ipg clock disable
Don't disable the ipg clock in the regulator error path. The clock is
disable unconditionally two lines below the failed_regulator label.
Signed-off-by: Baruch Siach <baruch@tkos.co.il>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: fix the clk mismatch in failed_reset path
Fix the clk mismatch in the error path "failed_reset" because
below error path will disable clk_ahb and clk_ipg directly, it
should use pm_runtime_put_noidle() instead of pm_runtime_put()
to avoid to call runtime resume callback.
Reported-by: Baruch Siach <baruch@tkos.co.il>
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
Tested-by: Baruch Siach <baruch@tkos.co.il>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: Do not use netdev messages too early
When a valid MAC address is not found the current messages
are shown:
fec 2188000.ethernet (unnamed net_device) (uninitialized): Invalid MAC address: 00:00:00:00:00:00
fec 2188000.ethernet (unnamed net_device) (uninitialized): Using random MAC address: aa:9f:25:eb:7e:aa
Since the network device has not been registered at this point, it is better
to use dev_err()/dev_info() instead, which will provide cleaner log
messages like these:
fec 2188000.ethernet: Invalid MAC address: 00:00:00:00:00:00
fec 2188000.ethernet: Using random MAC address: aa:9f:25:eb:7e:aa
Tested on a imx6dl-pico-pi board.
Signed-off-by: Fabio Estevam <festevam@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec_main: Use dev_err() instead of pr_err()
dev_err() is more appropriate for printing error messages inside
drivers, so switch to dev_err().
Signed-off-by: Fabio Estevam <festevam@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
ethernet: remove redundant memset
kvzalloc already zeroes the memory during the allocation.
pci_alloc_consistent calls dma_alloc_coherent directly.
In commit 518a2f1925c3
("dma-mapping: zero memory returned from dma_alloc_*"),
dma_alloc_coherent has already zeroed the memory.
So the memset after these function is not needed.
Signed-off-by: Fuqian Huang <huangfq.daxian@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: Use skb accessors in network drivers
In preparation for unifying the skb_frag and bio_vec, use the fine
accessors which already exist and use skb_frag_t instead of
struct skb_frag_struct.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: use devm_platform_ioremap_resource() to simplify code
Use devm_platform_ioremap_resource() to simplify the code a bit.
This is detected by coccinelle.
Reported-by: Hulk Robot <hulkci@huawei.com>
Signed-off-by: YueHaibing <yuehaibing@huawei.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: add C45 MDIO read/write support
IEEE 802.3ae clause 45 defines a modified MDIO protocol that uses a two
staged access model in order to increase the address space.
This patch adds support for C45 MDIO read and write accesses, which are
used whenever the MII_ADDR_C45 flag in the regnum argument is set.
In case it is not set, C22 accesses are used as before.
Signed-off-by: Marco Hartmann <marco.hartmann@nxp.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: remove redundant assignment to pointer bdp
The pointer bdp is being assigned with a value that is never
read, so the assignment is redundant and hence can be removed.
Addresses-Coverity: ("Unused value")
Signed-off-by: Colin Ian King <colin.king@canonical.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: Let fec_ptp have its own interrupt routine
This is better for code locality and should slightly
speed up normal interrupts.
This also allows PPS clock output to start working for
i.mx7. This is because i.mx7 was already using the limit
of 3 interrupts, and needed another.
Signed-off-by: Troy Kisky <troy.kisky@boundarydevices.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: remove stale comment
This comment is outdated as fec_ptp_ioctl has been replaced by fec_ptp_set/fec_ptp_get
since commit 1d5244d0e43b ("fec: Implement the SIOCGHWTSTAMP ioctl")
Signed-off-by: YueHaibing <yuehaibing@huawei.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: ptp: Switch to SPDX identifier
Adopt the SPDX license identifier headers to ease license compliance
management.
Signed-off-by: Fabio Estevam <fabio.estevam@nxp.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: remove redundant variable 'inc'
Variable 'inc' is being assigned but is never used hence it is
redundant and can be removed.
Cleans up clang warning:
warning: variable 'inc' set but not used [-Wunused-but-set-variable]
Signed-off-by: Colin Ian King <colin.king@canonical.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec_ptp: Use dev_err() instead of pr_err()
dev_err() is more appropriate for printing error messages inside
drivers, so switch to dev_err().
Signed-off-by: Fabio Estevam <festevam@gmail.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec_ptp: Use platform_get_irq_xxx_optional() to avoid error message
Use platform_get_irq_byname_optional() and platform_get_irq_optional()
instead of platform_get_irq_byname() and platform_get_irq() for optional
IRQs to avoid below error message during probe:
[ 0.795803] fec 30be0000.ethernet: IRQ pps not found
[ 0.800787] fec 30be0000.ethernet: IRQ index 3 not found
Signed-off-by: Anson Huang <Anson.Huang@nxp.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Reviewed-by: Stephen Boyd <swboyd@chromium.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: ethernet: freescale: fix false-positive string overflow warning
While compile-testing on arm64 with gcc-8.1, I ran into a build diagnostic:
kernel/drivers/net/drivers/freescale/fec_main.c: In function 'fec_probe':
kernel/drivers/net/drivers/freescale/fec_main.c:3517:25: error: '%d' directive writing between 1 and 10 bytes into a region of size 5 [-Werror=format-overflow=]
sprintf(irq_name, "int%d", i);
^~
kernel/drivers/net/drivers/freescale/fec_main.c:3517:21: note: directive argument in the range [0, 2147483646]
sprintf(irq_name, "int%d", i);
^~~~~~~
kernel/drivers/net/drivers/freescale/fec_main.c:3517:3: note: 'sprintf' output between 5 and 14 bytes into a destination of size 8
sprintf(irq_name, "int%d", i);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
It appears this has never shown on ppc32 or arm32 for an unknown reason, but
now gcc fails to identify that the 'irq_cnt' loop index has an upper bound
of 3, and instead uses a bogus range.
To work around the warning, this changes the sprintf to snprintf with the
correct buffer length.
Fixes: 78cc6e7ef957 ("net: ethernet: freescale: Allow FEC with COMPILE_TEST")
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec_main: Use platform_get_irq_byname_optional() to avoid error message
Failed to get irq using name is NOT fatal as driver will use index
to get irq instead, use platform_get_irq_byname_optional() instead
of platform_get_irq_byname() to avoid below error message during
probe:
[ 0.819312] fec 30be0000.ethernet: IRQ int0 not found
[ 0.824433] fec 30be0000.ethernet: IRQ int1 not found
[ 0.829539] fec 30be0000.ethernet: IRQ int2 not found
Signed-off-by: Anson Huang <Anson.Huang@nxp.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Reviewed-by: Stephen Boyd <swboyd@chromium.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: add missed clk_disable_unprepare in remove
This driver forgets to disable and unprepare clks when remove.
Add calls to clk_disable_unprepare to fix it.
Signed-off-by: Chuhong Yuan <hslester96@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: fix clock count mis-match
pm_runtime_put_autosuspend in probe will call runtime suspend to
disable clks automatically if CONFIG_PM is defined. (If CONFIG_PM
is not defined, its implementation will be empty, then runtime
suspend will not be called.)
Therefore, we can call pm_runtime_get_sync to runtime resume it
first to enable clks, which matches the runtime suspend. (Only when
CONFIG_PM is defined, otherwise pm_runtime_get_sync will also be
empty, then runtime resume will not be called.)
Then it is fine to disable clks without causing clock count mis-match.
Fixes: c43eab3eddb4 ("net: fec: add missed clk_disable_unprepare in remove")
Signed-off-by: Chuhong Yuan <hslester96@gmail.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: freescale: fec: Fix ethtool -d runtime PM
In order to dump the FECs registers the clocks have to be ticking,
otherwise a data abort occurs. Add calls to runtime PM so they are
enabled and later disabled.
Fixes: e8fcfcd5684a ("net: fec: optimize the clock management to save power")
Reported-by: Chris Healy <Chris.Healy@zii.aero>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: validate the new settings in fec_enet_set_coalesce()
[ Upstream commit ab14961d10d02d20767612c78ce148f6eb85bd58 ]
fec_enet_set_coalesce() validates the previously set params
and if they are within range proceeds to apply the new ones.
The new ones, however, are not validated. This seems backwards,
probably a copy-paste error?
Compile tested only.
Fixes: d851b47b22fc ("net: fec: add interrupt coalescence feature support")
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
----------
net: fec: add imx8mq and imx8qm new versions support
The ENET of imx8mq and imx8qm are basically the same as imx6sx,
but they have new features support based on imx6sx, like:
- imx8mq: supports IEEE 802.3az EEE standard.
- imx8qm: supports RGMII mode delayed clock.
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
----------
net: fec: add stop mode support for imx8 platform
The current driver support stop mode by calling machine api.
The patch add dts support to set gpr register for stop request.
imx8mq enter stop/exit stop mode by setting GPR bit, which can
be accessed by A core.
imx8qm enter stop/exit stop mode by calling IMX_SC ipc APIs that
communicate with M core ipc service, and the M core set the related
GPR bit at last.
After magic pattern coming during system suspend status, system will
be waked up, and irq handler will be called, then registers access
cause system hang due to clocks are off. So disable wake up irq in
.suspend(), and enable it in .resume().
Signed-off-by: Fugang Duan <B38611@freescale.com>
----------
MLK-16782 net: fec: double check the mii interrupt status
Double check the mii interrupt status during mdio bus accessing
to avoid interrupt lost in timeout case.
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
----------
net: fec: update scu ctrl name
The scu ctrl name is updated, so update driver accordingly
Signed-off-by: Dong Aisheng <aisheng.dong@nxp.com>
----------
net: fec: avoid imx_sc_misc_set_control() is called at atomic context
Avoid SCU interface like imx_sc_misc_set_control() is called at
atomic context.
Signed-off-by: Fugang Duan <B38611@freescale.com>
----------
net: fec: fix the typo for the property string "fsl,wakeup_irq"
Fix the typo for the property string "fsl,wakeup_irq".
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
----------
MLK-23687-01 net: fec: add stop mode support for imx8dxl
Enable stop mode for imx8dxl.
Reviewed-by: Joakim Zhang <qiangqing.zhang@nxp.com>
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
----------
MLK-24341 net: fec: fix the uninitialized variable in fec_resume()
Coverity reprot: CID = 6473151
The variable will contain an arbitrary value left from earlier computations.
In fec_resume, it uses of an uninitialized variable.
Reviewed-by: Richard Zhu <hongxing.zhu@nxp.com>
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
----------
net: fec: correct the error path for regulator disable in probe
[ Upstream commit c6165cf0dbb82ded90163dce3ac183fc7a913dc4 ]
Correct the error path for regulator disable.
Fixes: 9269e5560b26 ("net: fec: add phy-reset-gpios PROBE_DEFER check")
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Sasha Levin <sashal@kernel.org>
----------
MLK-20190-01 ptp: fec: add clock rate zero check
Add clock rate zero check to fixes coverity issue of "divide by 0".
Reviewed-by: Haibo Chen <haibo.chen@nxp.com>
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
Signed-off-by: Arulpandiyan Vadivel <arulpandiyan_vadivel@mentor.com>
----------
net: fec: change the default rx copybreak value to maximum
Set the default rx copybreak value to maximum that can improve
the performance when SMMU is enabled. User can change the copybreak
vaule in dynamically by ethtool.
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
----------
net: fec: add defer probe for of_get_mac_address
If MAC address read from nvmem efuse by calling .of_get_mac_address(),
but nvmem efuse is registerred later than the driver, then it
return -EPROBE_DEFER value. So modify the driver to support
defer probe when read MAC address from nvmem efuse.
Updates for v2:
avoid memory leak that the queues allocated by fec_enet_alloc_queue().
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
----------
MLK-9786 net: fec: Add busfreq support to the driver
Add request_bus_freq() and release_bus_freq() calls to the
various drivers to ensure that the DDR and AHB are the requested
frequency before the driver starts its task.
Signed-off-by: Fugang Duan <B38611@freescale.com>
Signed-off-by: Vipul Kumar <vipul_kumar@mentor.com>
Signed-off-by: Leonard Crestez <leonard.crestez@nxp.com>
----------
net: fec: Fix keeping busfreq high on probe defer
Add release_bus_freq on probe exit path.
This was exposed by commit 95ea0158b3fe ("net: fec: add defer probe for
of_get_mac_address")
Signed-off-by: Leonard Crestez <leonard.crestez@nxp.com>
Acked-by: Fugang Duan <fugang.duan@nxp.com>
Fixes: fed31bc87f36 ("MLK-9786 net: fec: Add busfreq support to the driver")
----------
net: fec: remove workaround to restart phylib state machine on MDIO timeout
There's a workaround to restart the phylib state machine in case of a
MDIO access timeout. Seems it was introduced to deal with the
consequences of a too small MDIO timeout. See also commit message of
c3b084c24c8a ("net: fec: Adjust ENET MDIO timeouts") which increased
the timeout value later. Due to the later timeout value fix it seems
to be safe to remove the workaround.
Signed-off-by: Heiner Kallweit <hkallweit1@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
----------
net: fec: fix the potential memory leak in fec_enet_init()
If the memory allocated for cbd_base is failed, it should
free the memory allocated for the queues, otherwise it causes
memory leak.
And if the memory allocated for the queues is failed, it can
return error directly.
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>
---
kernel/drivers/net/drivers/freescale/fec.h | 42 +-
.../drivers/net/drivers/freescale/fec_main.c | 534 +++++++++++++-----
.../drivers/net/drivers/freescale/fec_ptp.c | 110 ++--
3 files changed, 499 insertions(+), 187 deletions(-)
diff --git a/kernel/drivers/net/drivers/freescale/fec.h b/kernel/drivers/net/drivers/freescale/fec.h
index 185aa6463..5ab51701d 100644
--- a/kernel/drivers/net/drivers/freescale/fec.h
+++ b/kernel/drivers/net/drivers/freescale/fec.h
@@ -20,8 +20,14 @@
#include <linux/timecounter.h>
#include <rtnet_port.h>
+#ifdef CONFIG_IMX_SCU_SOC
+#include <dt-bindings/firmware/imx/rsrc.h>
+#include <linux/firmware/imx/sci.h>
+#endif
+
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
- defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
+ defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM) || \
+ defined(CONFIG_ARM64) || defined(CONFIG_COMPILE_TEST)
/*
* Just figures, Motorola would have to change the offsets for
* registers in the same peripheral device on different models
@@ -196,7 +202,7 @@
* Evidently, ARM SoCs have the FEC block generated in a
* little endian mode so adjust endianness accordingly.
*/
-#if defined(CONFIG_ARM)
+#if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
#define fec32_to_cpu le32_to_cpu
#define fec16_to_cpu le16_to_cpu
#define cpu_to_fec32 cpu_to_le32
@@ -452,6 +458,27 @@ struct bufdesc_ex {
* initialisation.
*/
#define FEC_QUIRK_MIB_CLEAR (1 << 15)
+/* Only i.MX25/i.MX27/i.MX28 controller supports FRBR,FRSR registers,
+ * those FIFO receive registers are resolved in other platforms.
+ */
+#define FEC_QUIRK_HAS_FRREG (1 << 16)
+/* i.MX8MQ ENET IP version add new feature to support IEEE 802.3az EEE
+ * standard. For the transmission, MAC supply two user registers to set
+ * Sleep (TS) and Wake (TW) time.
+ */
+#define FEC_QUIRK_HAS_EEE (1 << 17)
+/* i.MX8QM ENET IP version add new feture to generate delayed TXC/RXC
+ * as an alternative option to make sure it works well with various PHYs.
+ * For the implementation of delayed clock, ENET takes synchronized 250MHz
+ * clocks to generate 2ns delay.
+ */
+#define FEC_QUIRK_DELAYED_CLKS_SUPPORT (1 << 18)
+
+struct fec_enet_stop_mode {
+ struct regmap *gpr;
+ u8 req_gpr;
+ u8 req_bit;
+};
struct bufdesc_prop {
int qid;
@@ -541,7 +568,6 @@ struct fec_enet_private {
/* Phylib and MDIO interface */
struct mii_bus *mii_bus;
- int mii_timeout;
uint phy_speed;
phy_interface_t phy_interface;
struct device_node *phy_node;
@@ -554,6 +580,7 @@ struct fec_enet_private {
bool bufdesc_ex;
int pause_flag;
int wol_flag;
+ int wake_irq;
u32 quirks;
struct napi_struct napi;
@@ -596,15 +623,20 @@ struct fec_enet_private {
int pps_enable;
unsigned int next_counter;
+ /* stop mode */
+ struct fec_enet_stop_mode lpm;
+#ifdef CONFIG_IMX_SCU_SOC
+ struct imx_sc_ipc *ipc_handle;
+#endif
+
u64 ethtool_stats[0];
};
-void fec_ptp_init(struct platform_device *pdev);
+void fec_ptp_init(struct platform_device *pdev, int irq_idx);
void fec_ptp_stop(struct platform_device *pdev);
void fec_ptp_start_cyclecounter(struct net_device *ndev);
int fec_ptp_set(struct net_device *ndev, struct ifreq *ifr);
int fec_ptp_get(struct net_device *ndev, struct ifreq *ifr);
-uint fec_ptp_check_pps_event(struct fec_enet_private *fep);
/****************************************************************************/
#endif /* FEC_H */
diff --git a/kernel/drivers/net/drivers/freescale/fec_main.c b/kernel/drivers/net/drivers/freescale/fec_main.c
index 41c2fb1da..62e8d5158 100644
--- a/kernel/drivers/net/drivers/freescale/fec_main.c
+++ b/kernel/drivers/net/drivers/freescale/fec_main.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0+
/*
* Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
* Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
@@ -47,6 +48,7 @@
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/clk.h>
+#include <linux/crc32.h>
#include <linux/platform_device.h>
#include <linux/mdio.h>
#include <linux/phy.h>
@@ -59,8 +61,12 @@
#include <linux/regulator/consumer.h>
#include <linux/if_vlan.h>
#include <linux/pinctrl/consumer.h>
+#include <linux/pm_runtime.h>
+#include <linux/busfreq-imx.h>
#include <linux/prefetch.h>
#include <soc/imx/cpuidle.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
#include <asm/cacheflush.h>
@@ -92,14 +98,16 @@ static struct platform_device_id fec_devtype[] = {
.driver_data = 0,
}, {
.name = "imx25-fec",
- .driver_data = FEC_QUIRK_USE_GASKET | FEC_QUIRK_MIB_CLEAR,
+ .driver_data = FEC_QUIRK_USE_GASKET | FEC_QUIRK_MIB_CLEAR |
+ FEC_QUIRK_HAS_FRREG,
}, {
.name = "imx27-fec",
- .driver_data = FEC_QUIRK_MIB_CLEAR,
+ .driver_data = FEC_QUIRK_MIB_CLEAR | FEC_QUIRK_HAS_FRREG,
}, {
.name = "imx28-fec",
.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_SWAP_FRAME |
- FEC_QUIRK_SINGLE_MDIO | FEC_QUIRK_HAS_RACC,
+ FEC_QUIRK_SINGLE_MDIO | FEC_QUIRK_HAS_RACC |
+ FEC_QUIRK_HAS_FRREG,
}, {
.name = "imx6q-fec",
.driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
@@ -123,6 +131,22 @@ static struct platform_device_id fec_devtype[] = {
FEC_QUIRK_HAS_VLAN | FEC_QUIRK_ERR007885 |
FEC_QUIRK_BUG_CAPTURE | FEC_QUIRK_HAS_RACC |
FEC_QUIRK_HAS_COALESCE,
+ }, {
+ .name = "imx8mq-fec",
+ .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
+ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
+ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB |
+ FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE |
+ FEC_QUIRK_HAS_RACC | FEC_QUIRK_HAS_COALESCE |
+ FEC_QUIRK_HAS_EEE,
+ }, {
+ .name = "imx8qm-fec",
+ .driver_data = FEC_QUIRK_ENET_MAC | FEC_QUIRK_HAS_GBIT |
+ FEC_QUIRK_HAS_BUFDESC_EX | FEC_QUIRK_HAS_CSUM |
+ FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB |
+ FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE |
+ FEC_QUIRK_HAS_RACC | FEC_QUIRK_HAS_COALESCE |
+ FEC_QUIRK_DELAYED_CLKS_SUPPORT,
}, {
/* sentinel */
}
@@ -137,6 +161,8 @@ enum imx_fec_type {
MVF600_FEC,
IMX6SX_FEC,
IMX6UL_FEC,
+ IMX8MQ_FEC,
+ IMX8QM_FEC,
};
static const struct of_device_id fec_dt_ids[] = {
@@ -147,6 +173,8 @@ static const struct of_device_id fec_dt_ids[] = {
{ .compatible = "fsl,mvf600-fec", .data = &fec_devtype[MVF600_FEC], },
{ .compatible = "fsl,imx6sx-fec", .data = &fec_devtype[IMX6SX_FEC], },
{ .compatible = "fsl,imx6ul-fec", .data = &fec_devtype[IMX6UL_FEC], },
+ { .compatible = "fsl,imx8mq-fec", .data = &fec_devtype[IMX8MQ_FEC], },
+ { .compatible = "fsl,imx8qm-fec", .data = &fec_devtype[IMX8QM_FEC], },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, fec_dt_ids);
@@ -198,7 +226,8 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
* account when setting it.
*/
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
- defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
+ defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM) || \
+ defined(CONFIG_ARM64)
#define OPT_FRAME_SIZE (PKT_MAXBUF_SIZE << 16)
#else
#define OPT_FRAME_SIZE 0
@@ -206,8 +235,11 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
/* FEC MII MMFR bits definition */
#define FEC_MMFR_ST (1 << 30)
+#define FEC_MMFR_ST_C45 (0)
#define FEC_MMFR_OP_READ (2 << 28)
+#define FEC_MMFR_OP_READ_C45 (3 << 28)
#define FEC_MMFR_OP_WRITE (1 << 28)
+#define FEC_MMFR_OP_ADDR_WRITE (0)
#define FEC_MMFR_PA(v) ((v & 0x1f) << 23)
#define FEC_MMFR_RA(v) ((v & 0x1f) << 18)
#define FEC_MMFR_TA (2 << 16)
@@ -227,7 +259,15 @@ MODULE_PARM_DESC(macaddr, "FEC Ethernet MAC address");
#define FEC_WOL_FLAG_ENABLE (0x1 << 1)
#define FEC_WOL_FLAG_SLEEP_ON (0x1 << 2)
-#define COPYBREAK_DEFAULT 256
+/* By default, set the copybreak to 1518,
+ * then the RX path always keep DMA memory unchanged, and
+ * allocate one new skb and copy DMA memory data to the new skb
+ * buffer, which can improve the performance when SMMU is enabled.
+ *
+ * The driver support .set_tunable() interface for ethtool, user
+ * can dynamicly change the copybreak value.
+ */
+#define COPYBREAK_DEFAULT 1518
/* Max number of allowed TCP segments for software TSO */
#define FEC_MAX_TSO_SEGS 100
@@ -447,7 +487,7 @@ fec_enet_txq_submit_frag_skb(struct fec_enet_priv_tx_q *txq,
status = fec16_to_cpu(bdp->cbd_sc);
status &= ~BD_ENET_TX_STATS;
status |= (BD_ENET_TX_TC | BD_ENET_TX_READY);
- frag_len = skb_shinfo(skb)->frags[frag].size;
+ frag_len = skb_frag_size(&skb_shinfo(skb)->frags[frag]);
/* Handle the last BD specially */
if (frag == nr_frags - 1) {
@@ -469,7 +509,7 @@ fec_enet_txq_submit_frag_skb(struct fec_enet_priv_tx_q *txq,
ebdp->cbd_esc = cpu_to_fec32(estatus);
}
- bufaddr = page_address(this_frag->page.p) + this_frag->page_offset;
+ bufaddr = skb_frag_address(this_frag);
index = fec_enet_get_bd_index(bdp, &txq->bd);
if (((unsigned long) bufaddr) & fep->tx_align ||
@@ -1303,11 +1343,81 @@ fec_restart(struct net_device *ndev)
}
+#ifdef CONFIG_IMX_SCU_SOC
+static int fec_enet_ipc_handle_init(struct fec_enet_private *fep)
+{
+ if (!(of_machine_is_compatible("fsl,imx8qm") ||
+ of_machine_is_compatible("fsl,imx8qxp") ||
+ of_machine_is_compatible("fsl,imx8dxl")))
+ return 0;
+
+ return imx_scu_get_handle(&fep->ipc_handle);
+}
+
+static void fec_enet_ipg_stop_set(struct fec_enet_private *fep, bool enabled)
+{
+ struct device_node *np = fep->pdev->dev.of_node;
+ u32 rsrc_id, val;
+ int idx;
+
+ if (!np || !fep->ipc_handle)
+ return;
+
+ idx = of_alias_get_id(np, "ethernet");
+ if (idx < 0)
+ idx = 0;
+ rsrc_id = idx ? IMX_SC_R_ENET_1 : IMX_SC_R_ENET_0;
+
+ val = enabled ? 1 : 0;
+ imx_sc_misc_set_control(fep->ipc_handle, rsrc_id, IMX_SC_C_IPG_STOP, val);
+}
+#else
+static int fec_enet_ipc_handle_init(struct fec_enet_private *fep)
+{
+ return 0;
+}
+
+static void fec_enet_ipg_stop_set(struct fec_enet_private *fep, bool enabled) {}
+#endif
+
+static void fec_enet_enter_stop_mode(struct fec_enet_private *fep)
+{
+ struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
+
+ if (!IS_ERR_OR_NULL(fep->lpm.gpr))
+ regmap_update_bits(fep->lpm.gpr, fep->lpm.req_gpr,
+ 1 << fep->lpm.req_bit,
+ 1 << fep->lpm.req_bit);
+ else if (pdata && pdata->sleep_mode_enable)
+ pdata->sleep_mode_enable(true);
+ else
+ fec_enet_ipg_stop_set(fep, true);
+}
+
+static void fec_enet_exit_stop_mode(struct fec_enet_private *fep)
+{
+ struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
+
+ if (!IS_ERR_OR_NULL(fep->lpm.gpr))
+ regmap_update_bits(fep->lpm.gpr, fep->lpm.req_gpr,
+ 1 << fep->lpm.req_bit, 0);
+ else if (pdata && pdata->sleep_mode_enable)
+ pdata->sleep_mode_enable(false);
+ else
+ fec_enet_ipg_stop_set(fep, false);
+}
+
+static inline void fec_irqs_disable(struct net_device *ndev)
+{
+ struct fec_enet_private *fep = netdev_priv(ndev);
+
+ writel(0, fep->hwp + FEC_IMASK);
+}
+
static void
fec_stop(struct net_device *ndev)
{
struct fec_enet_private *fep = netdev_priv(ndev);
- struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
u32 rmii_mode = readl(fep->hwp + FEC_R_CNTRL) & (1 << 8);
u32 val;
@@ -1330,15 +1440,12 @@ fec_stop(struct net_device *ndev)
writel(1, fep->hwp + FEC_ECNTRL);
udelay(10);
}
- writel(FEC_DEFAULT_IMASK, fep->hwp + FEC_IMASK);
+ writel(FEC_ENET_MII, fep->hwp + FEC_IMASK);
} else {
- writel(FEC_DEFAULT_IMASK | FEC_ENET_WAKEUP, fep->hwp + FEC_IMASK);
+ writel(FEC_ENET_MII | FEC_ENET_WAKEUP, fep->hwp + FEC_IMASK);
val = readl(fep->hwp + FEC_ECNTRL);
val |= (FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
writel(val, fep->hwp + FEC_ECNTRL);
-
- if (pdata && pdata->sleep_mode_enable)
- pdata->sleep_mode_enable(true);
}
writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
@@ -2104,10 +2211,6 @@ fec_enet_interrupt(int irq, void *dev_id)
ret = IRQ_HANDLED;
complete(&fep->mdio_done);
}
-
- if (fep->ptp_clock)
- if (fec_ptp_check_pps_event(fep))
- ret = IRQ_HANDLED;
return ret;
}
@@ -2156,7 +2259,7 @@ static int fec_enet_rx_napi(struct napi_struct *napi, int budget)
}
/* ------------------------------------------------------------------------- */
-static void fec_get_mac(struct net_device *ndev)
+static int fec_get_mac(struct net_device *ndev)
{
struct fec_enet_private *fep = netdev_priv(ndev);
struct fec_platform_data *pdata = dev_get_platdata(&fep->pdev->dev);
@@ -2177,8 +2280,10 @@ static void fec_get_mac(struct net_device *ndev)
struct device_node *np = fep->pdev->dev.of_node;
if (np) {
const char *mac = of_get_mac_address(np);
- if (mac)
+ if (!IS_ERR(mac))
iap = (unsigned char *) mac;
+ else if (PTR_ERR(mac) == -EPROBE_DEFER)
+ return -EPROBE_DEFER;
}
}
@@ -2211,11 +2316,11 @@ static void fec_get_mac(struct net_device *ndev)
*/
if (!is_valid_ether_addr(iap)) {
/* Report it and use a random ethernet address instead */
- netdev_err(ndev, "Invalid MAC address: %pM\n", iap);
+ dev_err(&fep->pdev->dev, "Invalid MAC address: %pM\n", iap);
eth_hw_addr_random(ndev);
- netdev_info(ndev, "Using random MAC address: %pM\n",
- ndev->dev_addr);
- return;
+ dev_info(&fep->pdev->dev, "Using random MAC address: %pM\n",
+ ndev->dev_addr);
+ return 0;
}
memcpy(ndev->dev_addr, iap, ETH_ALEN);
@@ -2223,6 +2328,8 @@ static void fec_get_mac(struct net_device *ndev)
/* Adjust MAC if using macaddr */
if (iap == macaddr)
ndev->dev_addr[ETH_ALEN-1] = macaddr[ETH_ALEN-1] + fep->dev_id;
+
+ return 0;
}
/* ------------------------------------------------------------------------- */
@@ -2236,12 +2343,6 @@ static void do_adjust_link(struct net_device *ndev)
struct phy_device *phy_dev = ndev->phydev;
int status_change = 0;
- /* Prevent a state halted on mii error */
- if (fep->mii_timeout && phy_dev->state == PHY_HALTED) {
- phy_dev->state = PHY_RESUMING;
- return;
- }
-
/*
* If the netdev is down, or is going down, we're not interested
* in link state events, so just mark our idea of the link as down
@@ -2311,28 +2412,59 @@ static int fec_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
struct fec_enet_private *fep = bus->priv;
struct device *dev = &fep->pdev->dev;
unsigned long time_left;
- int ret = 0;
+ uint int_events;
+ int ret = 0, frame_start, frame_addr, frame_op;
+ bool is_c45 = !!(regnum & MII_ADDR_C45);
ret = pm_runtime_get_sync(dev);
if (ret < 0)
return ret;
- fep->mii_timeout = 0;
reinit_completion(&fep->mdio_done);
+ if (is_c45) {
+ frame_start = FEC_MMFR_ST_C45;
+
+ /* write address */
+ frame_addr = (regnum >> 16);
+ writel(frame_start | FEC_MMFR_OP_ADDR_WRITE |
+ FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
+ FEC_MMFR_TA | (regnum & 0xFFFF),
+ fep->hwp + FEC_MII_DATA);
+
+ /* wait for end of transfer */
+ time_left = wait_for_completion_timeout(&fep->mdio_done,
+ usecs_to_jiffies(FEC_MII_TIMEOUT));
+ if (time_left == 0) {
+ netdev_err(fep->netdev, "MDIO address write timeout\n");
+ ret = -ETIMEDOUT;
+ goto out;
+ }
+
+ frame_op = FEC_MMFR_OP_READ_C45;
+
+ } else {
+ /* C22 read */
+ frame_op = FEC_MMFR_OP_READ;
+ frame_start = FEC_MMFR_ST;
+ frame_addr = regnum;
+ }
+
/* start a read op */
- writel(FEC_MMFR_ST | FEC_MMFR_OP_READ |
- FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
+ writel(frame_start | frame_op |
+ FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
FEC_MMFR_TA, fep->hwp + FEC_MII_DATA);
/* wait for end of transfer */
time_left = wait_for_completion_timeout(&fep->mdio_done,
usecs_to_jiffies(FEC_MII_TIMEOUT));
if (time_left == 0) {
- fep->mii_timeout = 1;
- netdev_err(fep->netdev, "MDIO read timeout\n");
- ret = -ETIMEDOUT;
- goto out;
+ int_events = readl(fep->hwp + FEC_IEVENT);
+ if (!(int_events & FEC_ENET_MII)) {
+ netdev_err(fep->netdev, "MDIO read timeout\n");
+ ret = -ETIMEDOUT;
+ goto out;
+ }
}
ret = FEC_MMFR_DATA(readl(fep->hwp + FEC_MII_DATA));
@@ -2350,7 +2482,8 @@ static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
struct fec_enet_private *fep = bus->priv;
struct device *dev = &fep->pdev->dev;
unsigned long time_left;
- int ret;
+ int ret, frame_start, frame_addr;
+ bool is_c45 = !!(regnum & MII_ADDR_C45);
ret = pm_runtime_get_sync(dev);
if (ret < 0)
@@ -2358,12 +2491,35 @@ static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
else
ret = 0;
- fep->mii_timeout = 0;
reinit_completion(&fep->mdio_done);
+ if (is_c45) {
+ frame_start = FEC_MMFR_ST_C45;
+
+ /* write address */
+ frame_addr = (regnum >> 16);
+ writel(frame_start | FEC_MMFR_OP_ADDR_WRITE |
+ FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
+ FEC_MMFR_TA | (regnum & 0xFFFF),
+ fep->hwp + FEC_MII_DATA);
+
+ /* wait for end of transfer */
+ time_left = wait_for_completion_timeout(&fep->mdio_done,
+ usecs_to_jiffies(FEC_MII_TIMEOUT));
+ if (time_left == 0) {
+ netdev_err(fep->netdev, "MDIO address write timeout\n");
+ ret = -ETIMEDOUT;
+ goto out;
+ }
+ } else {
+ /* C22 write */
+ frame_start = FEC_MMFR_ST;
+ frame_addr = regnum;
+ }
+
/* start a write op */
- writel(FEC_MMFR_ST | FEC_MMFR_OP_WRITE |
- FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(regnum) |
+ writel(frame_start | FEC_MMFR_OP_WRITE |
+ FEC_MMFR_PA(mii_id) | FEC_MMFR_RA(frame_addr) |
FEC_MMFR_TA | FEC_MMFR_DATA(value),
fep->hwp + FEC_MII_DATA);
@@ -2371,11 +2527,11 @@ static int fec_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
time_left = wait_for_completion_timeout(&fep->mdio_done,
usecs_to_jiffies(FEC_MII_TIMEOUT));
if (time_left == 0) {
- fep->mii_timeout = 1;
netdev_err(fep->netdev, "MDIO write timeout\n");
ret = -ETIMEDOUT;
}
+out:
pm_runtime_mark_last_busy(dev);
pm_runtime_put_autosuspend(dev);
@@ -2388,13 +2544,9 @@ static int fec_enet_clk_enable(struct net_device *ndev, bool enable)
int ret;
if (enable) {
- ret = clk_prepare_enable(fep->clk_ahb);
- if (ret)
- return ret;
-
ret = clk_prepare_enable(fep->clk_enet_out);
if (ret)
- goto failed_clk_enet_out;
+ return ret;
if (fep->clk_ptp) {
mutex_lock(&fep->ptp_clk_mutex);
@@ -2411,8 +2563,9 @@ static int fec_enet_clk_enable(struct net_device *ndev, bool enable)
ret = clk_prepare_enable(fep->clk_ref);
if (ret)
goto failed_clk_ref;
+
+ phy_reset_after_clk_enable(ndev->phydev);
} else {
- clk_disable_unprepare(fep->clk_ahb);
clk_disable_unprepare(fep->clk_enet_out);
if (fep->clk_ptp) {
mutex_lock(&fep->ptp_clk_mutex);
@@ -2431,8 +2584,6 @@ failed_clk_ref:
failed_clk_ptp:
if (fep->clk_enet_out)
clk_disable_unprepare(fep->clk_enet_out);
-failed_clk_enet_out:
- clk_disable_unprepare(fep->clk_ahb);
return ret;
}
@@ -2484,16 +2635,15 @@ static int fec_enet_mii_probe(struct net_device *ndev)
/* mask with MAC supported features */
if (fep->quirks & FEC_QUIRK_HAS_GBIT) {
- phy_dev->supported &= PHY_GBIT_FEATURES;
- phy_dev->supported &= ~SUPPORTED_1000baseT_Half;
+ phy_set_max_speed(phy_dev, 1000);
+ phy_remove_link_mode(phy_dev,
+ ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
#if !defined(CONFIG_M5272)
- phy_dev->supported |= SUPPORTED_Pause;
+ phy_support_sym_pause(phy_dev);
#endif
}
else
- phy_dev->supported &= PHY_BASIC_FEATURES;
-
- phy_dev->advertising = phy_dev->supported;
+ phy_set_max_speed(phy_dev, 100);
fep->link = 0;
fep->full_duplex = 0;
@@ -2538,8 +2688,6 @@ static int fec_enet_mii_init(struct platform_device *pdev)
return -ENOENT;
}
- fep->mii_timeout = 0;
-
/*
* Set MII speed to 2.5 MHz (= clk_get_rate() / 2 * phy_speed)
*
@@ -2592,13 +2740,8 @@ static int fec_enet_mii_init(struct platform_device *pdev)
fep->mii_bus->parent = &pdev->dev;
node = of_get_child_by_name(pdev->dev.of_node, "mdio");
- if (node) {
- err = of_mdiobus_register(fep->mii_bus, node);
- of_node_put(node);
- } else {
- err = mdiobus_register(fep->mii_bus);
- }
-
+ err = of_mdiobus_register(fep->mii_bus, node);
+ of_node_put(node);
if (err)
goto err_out_free_mdiobus;
@@ -2650,7 +2793,9 @@ static int fec_enet_get_regs_len(struct net_device *ndev)
/* List of registers that can be safety be read to dump them with ethtool */
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
- defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM)
+ defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARM) || \
+ defined(CONFIG_ARM64) || defined(CONFIG_COMPILE_TEST)
+static __u32 fec_enet_register_version = 2;
static u32 fec_enet_register_offset[] = {
FEC_IEVENT, FEC_IMASK, FEC_R_DES_ACTIVE_0, FEC_X_DES_ACTIVE_0,
FEC_ECNTRL, FEC_MII_DATA, FEC_MII_SPEED, FEC_MIB_CTRLSTAT, FEC_R_CNTRL,
@@ -2681,6 +2826,7 @@ static u32 fec_enet_register_offset[] = {
IEEE_R_FDXFC, IEEE_R_OCTETS_OK
};
#else
+static __u32 fec_enet_register_version = 1;
static u32 fec_enet_register_offset[] = {
FEC_ECNTRL, FEC_IEVENT, FEC_IMASK, FEC_IVEC, FEC_R_DES_ACTIVE_0,
FEC_R_DES_ACTIVE_1, FEC_R_DES_ACTIVE_2, FEC_X_DES_ACTIVE_0,
@@ -2699,15 +2845,32 @@ static void fec_enet_get_regs(struct net_device *ndev,
{
struct fec_enet_private *fep = netdev_priv(ndev);
u32 __iomem *theregs = (u32 __iomem *)fep->hwp;
+ struct device *dev = &fep->pdev->dev;
u32 *buf = (u32 *)regbuf;
u32 i, off;
+ int ret;
+
+ ret = pm_runtime_get_sync(dev);
+ if (ret < 0)
+ return;
+
+ regs->version = fec_enet_register_version;
memset(buf, 0, regs->len);
for (i = 0; i < ARRAY_SIZE(fec_enet_register_offset); i++) {
- off = fec_enet_register_offset[i] / 4;
+ off = fec_enet_register_offset[i];
+
+ if ((off == FEC_R_BOUND || off == FEC_R_FSTART) &&
+ !(fep->quirks & FEC_QUIRK_HAS_FRREG))
+ continue;
+
+ off >>= 2;
buf[off] = readl(&theregs[off]);
}
+
+ pm_runtime_mark_last_busy(dev);
+ pm_runtime_put_autosuspend(dev);
}
static int fec_enet_get_ts_info(struct net_device *ndev,
@@ -2771,13 +2934,8 @@ static int fec_enet_set_pauseparam(struct net_device *ndev,
fep->pause_flag |= pause->rx_pause ? FEC_PAUSE_FLAG_ENABLE : 0;
fep->pause_flag |= pause->autoneg ? FEC_PAUSE_FLAG_AUTONEG : 0;
- if (pause->rx_pause || pause->autoneg) {
- ndev->phydev->supported |= ADVERTISED_Pause;
- ndev->phydev->advertising |= ADVERTISED_Pause;
- } else {
- ndev->phydev->supported &= ~ADVERTISED_Pause;
- ndev->phydev->advertising &= ~ADVERTISED_Pause;
- }
+ phy_set_sym_pause(ndev->phydev, pause->rx_pause, pause->tx_pause,
+ pause->autoneg);
if (pause->autoneg) {
if (if_running(ndev))
@@ -2998,30 +3156,31 @@ static int
fec_enet_set_coalesce(struct net_device *ndev, struct ethtool_coalesce *ec)
{
struct fec_enet_private *fep = netdev_priv(ndev);
+ struct device *dev = &fep->pdev->dev;
unsigned int cycle;
if (!(fep->quirks & FEC_QUIRK_HAS_COALESCE))
return -EOPNOTSUPP;
if (ec->rx_max_coalesced_frames > 255) {
- pr_err("Rx coalesced frames exceed hardware limitation\n");
+ dev_err(dev, "Rx coalesced frames exceed hardware limitation\n");
return -EINVAL;
}
if (ec->tx_max_coalesced_frames > 255) {
- pr_err("Tx coalesced frame exceed hardware limitation\n");
+ dev_err(dev, "Tx coalesced frame exceed hardware limitation\n");
return -EINVAL;
}
- cycle = fec_enet_us_to_itr_clock(ndev, fep->rx_time_itr);
+ cycle = fec_enet_us_to_itr_clock(ndev, ec->rx_coalesce_usecs);
if (cycle > 0xFFFF) {
- pr_err("Rx coalesced usec exceed hardware limitation\n");
+ dev_err(dev, "Rx coalesced usec exceed hardware limitation\n");
return -EINVAL;
}
- cycle = fec_enet_us_to_itr_clock(ndev, fep->tx_time_itr);
+ cycle = fec_enet_us_to_itr_clock(ndev, ec->tx_coalesce_usecs);
if (cycle > 0xFFFF) {
- pr_err("Rx coalesced usec exceed hardware limitation\n");
+ dev_err(dev, "Tx coalesced usec exceed hardware limitation\n");
return -EINVAL;
}
@@ -3112,15 +3271,10 @@ fec_enet_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
return -EINVAL;
device_set_wakeup_enable(&ndev->dev, wol->wolopts & WAKE_MAGIC);
- if (device_may_wakeup(&ndev->dev)) {
+ if (device_may_wakeup(&ndev->dev))
fep->wol_flag |= FEC_WOL_FLAG_ENABLE;
- if (fep->irq[0] > 0)
- enable_irq_wake(fep->irq[0]);
- } else {
+ else
fep->wol_flag &= (~FEC_WOL_FLAG_ENABLE);
- if (fep->irq[0] > 0)
- disable_irq_wake(fep->irq[0]);
- }
return 0;
}
@@ -3216,7 +3370,6 @@ static void fec_enet_free_buffers(struct net_device *ndev)
for (q = 0; q < fep->num_tx_queues; q++) {
txq = fep->tx_queue[q];
- bdp = txq->bd.base;
for (i = 0; i < txq->bd.ring_size; i++) {
kfree(txq->tx_bounce[i]);
txq->tx_bounce[i] = NULL;
@@ -3417,6 +3570,7 @@ __fec_enet_open(struct net_device *ndev)
{
struct fec_enet_private *fep = netdev_priv(ndev);
int ret;
+ bool reset_again;
ret = pm_runtime_get_sync(&fep->pdev->dev);
if (ret < 0)
@@ -3427,6 +3581,17 @@ __fec_enet_open(struct net_device *ndev)
if (ret)
goto clk_enable;
+ /* During the first fec_enet_open call the PHY isn't probed at this
+ * point. Therefore the phy_reset_after_clk_enable() call within
+ * fec_enet_clk_enable() fails. As we need this reset in order to be
+ * sure the PHY is working correctly we check if we need to reset again
+ * later when the PHY is probed
+ */
+ if (ndev->phydev && ndev->phydev->drv)
+ reset_again = false;
+ else
+ reset_again = true;
+
/* I should reset the ring buffers here, but I don't yet know
* a simple way to do that.
*/
@@ -3443,6 +3608,12 @@ __fec_enet_open(struct net_device *ndev)
if (ret)
goto err_enet_mii_probe;
+ /* Call phy_reset_after_clk_enable() again if it failed during
+ * phy_reset_after_clk_enable() before because the PHY wasn't probed.
+ */
+ if (reset_again)
+ phy_reset_after_clk_enable(ndev->phydev);
+
if (fep->quirks & FEC_QUIRK_ERR006687)
imx6q_cpuidle_fec_irqs_used();
@@ -3555,7 +3726,7 @@ static void set_multicast_list(struct net_device *ndev)
{
struct fec_enet_private *fep = netdev_priv(ndev);
struct netdev_hw_addr *ha;
- unsigned int i, bit, data, crc, tmp;
+ unsigned int crc, tmp;
unsigned char hash;
unsigned int hash_high = 0, hash_low = 0;
@@ -3583,15 +3754,7 @@ static void set_multicast_list(struct net_device *ndev)
/* Add the addresses in hash register */
netdev_for_each_mc_addr(ha, ndev) {
/* calculate crc32 value of mac address */
- crc = 0xffffffff;
-
- for (i = 0; i < ndev->addr_len; i++) {
- data = ha->addr[i];
- for (bit = 0; bit < 8; bit++, data >>= 1) {
- crc = (crc >> 1) ^
- (((crc ^ data) & 1) ? CRC32_POLY : 0);
- }
- }
+ crc = ether_crc_le(ndev->addr_len, ha->addr);
/* only upper 6 bits (FEC_HASH_BITS) are used
* which point to specific bit in the hash registers
@@ -3792,9 +3955,10 @@ static int fec_enet_init(struct net_device *ndev)
unsigned dsize = fep->bufdesc_ex ? sizeof(struct bufdesc_ex) :
sizeof(struct bufdesc);
unsigned dsize_log2 = __fls(dsize);
+ int ret;
WARN_ON(dsize != (1 << dsize_log2));
-#if defined(CONFIG_ARM)
+#if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
fep->rx_align = 0xf;
fep->tx_align = 0xf;
#else
@@ -3802,7 +3966,16 @@ static int fec_enet_init(struct net_device *ndev)
fep->tx_align = 0x3;
#endif
- fec_enet_alloc_queue(ndev);
+ /* Check mask of the streaming and coherent API */
+ ret = dma_set_mask_and_coherent(&fep->pdev->dev, DMA_BIT_MASK(32));
+ if (ret < 0) {
+ dev_warn(&fep->pdev->dev, "No suitable DMA available\n");
+ return ret;
+ }
+
+ ret = fec_enet_alloc_queue(ndev);
+ if (ret)
+ return ret;
bd_size = (fep->total_tx_ring_size + fep->total_rx_ring_size) * dsize;
@@ -3810,13 +3983,15 @@ static int fec_enet_init(struct net_device *ndev)
cbd_base = dmam_alloc_coherent(&fep->pdev->dev, bd_size, &bd_dma,
GFP_KERNEL);
if (!cbd_base) {
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto free_queue_mem;
}
- memset(cbd_base, 0, bd_size);
-
/* Get the Ethernet address */
- fec_get_mac(ndev);
+ ret = fec_get_mac(ndev);
+ if (ret)
+ goto free_queue_mem;
+
/* make sure MAC we just acquired is programmed into the hw */
fec_set_mac_address(ndev, NULL);
@@ -3893,6 +4068,10 @@ static int fec_enet_init(struct net_device *ndev)
fec_enet_update_ethtool_stats(ndev);
return 0;
+
+free_queue_mem:
+ fec_enet_free_queue(ndev);
+ return ret;
}
#ifdef CONFIG_OF
@@ -3992,6 +4171,54 @@ fec_enet_get_queue_num(struct platform_device *pdev, int *num_tx, int *num_rx)
}
+static int fec_enet_get_irq_cnt(struct platform_device *pdev)
+{
+ int irq_cnt = platform_irq_count(pdev);
+
+ if (irq_cnt > FEC_IRQ_NUM)
+ irq_cnt = FEC_IRQ_NUM; /* last for pps */
+ else if (irq_cnt == 2)
+ irq_cnt = 1; /* last for pps */
+ else if (irq_cnt <= 0)
+ irq_cnt = 1; /* At least 1 irq is needed */
+ return irq_cnt;
+}
+
+static void fec_enet_of_parse_stop_mode(struct platform_device *pdev)
+{
+ struct net_device *dev = platform_get_drvdata(pdev);
+ struct device_node *np = pdev->dev.of_node;
+ struct fec_enet_private *fep = netdev_priv(dev);
+ struct device_node *node;
+ phandle phandle;
+ u32 out_val[3];
+ int ret;
+
+ ret = of_property_read_u32_array(np, "stop-mode", out_val, 3);
+ if (ret) {
+ dev_dbg(&pdev->dev, "no stop-mode property\n");
+ return;
+ }
+
+ phandle = *out_val;
+ node = of_find_node_by_phandle(phandle);
+ if (!node) {
+ dev_dbg(&pdev->dev, "could not find gpr node by phandle\n");
+ return;
+ }
+
+ fep->lpm.gpr = syscon_node_to_regmap(node);
+ if (IS_ERR(fep->lpm.gpr)) {
+ dev_dbg(&pdev->dev, "could not find gpr regmap\n");
+ return;
+ }
+
+ of_node_put(node);
+
+ fep->lpm.req_gpr = out_val[1];
+ fep->lpm.req_bit = out_val[2];
+}
+
static int fec_rt_init(struct net_device *ndev)
{
struct fec_enet_private *fep = netdev_priv(ndev);
@@ -4052,12 +4279,13 @@ fec_probe(struct platform_device *pdev)
struct fec_platform_data *pdata;
struct net_device *ndev;
int i, irq, ret = 0, eth_id;
- struct resource *r;
const struct of_device_id *of_id;
static int dev_id;
struct device_node *np = pdev->dev.of_node, *phy_node;
int num_tx_qs;
int num_rx_qs;
+ char irq_name[8];
+ int irq_cnt;
bool rtnet;
fec_enet_get_queue_num(pdev, &num_tx_qs, &num_rx_qs);
@@ -4099,8 +4327,7 @@ fec_probe(struct platform_device *pdev)
/* Select default pin state */
pinctrl_pm_select_default_state(&pdev->dev);
- r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- fep->hwp = devm_ioremap_resource(&pdev->dev, r);
+ fep->hwp = devm_platform_ioremap_resource(pdev, 0);
if (IS_ERR(fep->hwp)) {
ret = PTR_ERR(fep->hwp);
goto failed_ioremap;
@@ -4115,6 +4342,11 @@ fec_probe(struct platform_device *pdev)
!of_property_read_bool(np, "fsl,err006687-workaround-present"))
fep->quirks |= FEC_QUIRK_ERR006687;
+ fec_enet_of_parse_stop_mode(pdev);
+ ret = fec_enet_ipc_handle_init(fep);
+ if (ret)
+ goto failed_ipc_init;
+
if (of_get_property(np, "fsl,magic-packet", NULL))
fep->wol_flag |= FEC_WOL_HAS_MAGIC_PACKET;
@@ -4141,6 +4373,8 @@ fec_probe(struct platform_device *pdev)
fep->phy_interface = ret;
}
+ request_bus_freq(BUS_FREQ_HIGH);
+
fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
if (IS_ERR(fep->clk_ipg)) {
ret = PTR_ERR(fep->clk_ipg);
@@ -4187,14 +4421,16 @@ fec_probe(struct platform_device *pdev)
ret = clk_prepare_enable(fep->clk_ipg);
if (ret)
goto failed_clk_ipg;
+ ret = clk_prepare_enable(fep->clk_ahb);
+ if (ret)
+ goto failed_clk_ahb;
- fep->reg_phy = devm_regulator_get(&pdev->dev, "phy");
+ fep->reg_phy = devm_regulator_get_optional(&pdev->dev, "phy");
if (!IS_ERR(fep->reg_phy)) {
ret = regulator_enable(fep->reg_phy);
if (ret) {
dev_err(&pdev->dev,
"Failed to enable phy regulator: %d\n", ret);
- clk_disable_unprepare(fep->clk_ipg);
goto failed_regulator;
}
} else {
@@ -4215,18 +4451,20 @@ fec_probe(struct platform_device *pdev)
if (ret)
goto failed_reset;
+ irq_cnt = fec_enet_get_irq_cnt(pdev);
if (fep->bufdesc_ex)
- fec_ptp_init(pdev);
+ fec_ptp_init(pdev, irq_cnt);
ret = fec_enet_init(ndev);
if (ret)
goto failed_init;
- for (i = 0; i < FEC_IRQ_NUM; i++) {
- irq = platform_get_irq(pdev, i);
+ for (i = 0; i < irq_cnt; i++) {
+ snprintf(irq_name, sizeof(irq_name), "int%d", i);
+ irq = platform_get_irq_byname_optional(pdev, irq_name);
+ if (irq < 0)
+ irq = platform_get_irq(pdev, i);
if (irq < 0) {
- if (i)
- break;
ret = irq;
goto failed_irq;
}
@@ -4243,6 +4481,13 @@ fec_probe(struct platform_device *pdev)
fep->irqnr++;
}
+ /* get wake up irq */
+ ret = of_property_read_u32(np, "fsl,wakeup_irq", &irq);
+ if (!ret && irq < irq_cnt)
+ fep->wake_irq = fep->irq[irq];
+ else
+ fep->wake_irq = fep->irq[0];
+
init_completion(&fep->mdio_done);
ret = fec_enet_mii_init(pdev);
if (ret)
@@ -4286,18 +4531,23 @@ failed_irq:
rtdm_irq_free(&fep->rtnet.irq_handle[i]);
failed_init:
fec_ptp_stop(pdev);
- if (fep->reg_phy)
- regulator_disable(fep->reg_phy);
failed_reset:
- pm_runtime_put(&pdev->dev);
+ pm_runtime_put_noidle(&pdev->dev);
pm_runtime_disable(&pdev->dev);
+ if (fep->reg_phy)
+ regulator_disable(fep->reg_phy);
failed_regulator:
+ clk_disable_unprepare(fep->clk_ahb);
+failed_clk_ahb:
+ clk_disable_unprepare(fep->clk_ipg);
failed_clk_ipg:
fec_enet_clk_enable(ndev, false);
failed_clk:
+ release_bus_freq(BUS_FREQ_HIGH);
if (of_phy_is_fixed_link(np))
of_phy_deregister_fixed_link(np);
of_node_put(phy_node);
+failed_ipc_init:
failed_phy:
dev_id--;
failed_ioremap:
@@ -4316,6 +4566,11 @@ fec_drv_remove(struct platform_device *pdev)
struct fec_enet_private *fep = netdev_priv(ndev);
struct device_node *np = pdev->dev.of_node;
struct fec_rt_data *frt = &fep->rtnet;
+ int ret;
+
+ ret = pm_runtime_get_sync(&pdev->dev);
+ if (ret < 0)
+ return ret;
fec_ptp_stop(pdev);
cancel_work_sync(&fep->tx_timeout_work);
@@ -4325,13 +4580,17 @@ fec_drv_remove(struct platform_device *pdev)
fec_enet_mii_remove(fep);
if (fep->reg_phy)
regulator_disable(fep->reg_phy);
- pm_runtime_put(&pdev->dev);
- pm_runtime_disable(&pdev->dev);
+
if (of_phy_is_fixed_link(np))
of_phy_deregister_fixed_link(np);
of_node_put(fep->phy_node);
free_netdev(ndev);
+ clk_disable_unprepare(fep->clk_ahb);
+ clk_disable_unprepare(fep->clk_ipg);
+ pm_runtime_put_noidle(&pdev->dev);
+ pm_runtime_disable(&pdev->dev);
+
return 0;
}
@@ -4349,9 +4608,15 @@ static int __maybe_unused fec_suspend(struct device *dev)
netif_device_detach(ndev);
if_tx_unlock(ndev);
fec_stop(ndev);
- fec_enet_clk_enable(ndev, false);
- if (!(fep->wol_flag & FEC_WOL_FLAG_ENABLE))
+ if (!(fep->wol_flag & FEC_WOL_FLAG_ENABLE)) {
+ fec_irqs_disable(ndev);
pinctrl_pm_select_sleep_state(&fep->pdev->dev);
+ } else {
+ fec_enet_enter_stop_mode(fep);
+ disable_irq(fep->wake_irq);
+ enable_irq_wake(fep->wake_irq);
+ }
+ fec_enet_clk_enable(ndev, false);
}
rtnl_unlock();
@@ -4371,8 +4636,7 @@ static int __maybe_unused fec_resume(struct device *dev)
{
struct net_device *ndev = dev_get_drvdata(dev);
struct fec_enet_private *fep = netdev_priv(ndev);
- struct fec_platform_data *pdata = fep->pdev->dev.platform_data;
- int ret;
+ int ret = 0;
int val;
if (fep->reg_phy && !(fep->wol_flag & FEC_WOL_FLAG_ENABLE)) {
@@ -4389,8 +4653,9 @@ static int __maybe_unused fec_resume(struct device *dev)
goto failed_clk;
}
if (fep->wol_flag & FEC_WOL_FLAG_ENABLE) {
- if (pdata && pdata->sleep_mode_enable)
- pdata->sleep_mode_enable(false);
+ disable_irq_wake(fep->wake_irq);
+ fec_enet_exit_stop_mode(fep);
+ enable_irq(fep->wake_irq);
val = readl(fep->hwp + FEC_ECNTRL);
val &= ~(FEC_ECR_MAGICEN | FEC_ECR_SLEEP);
writel(val, fep->hwp + FEC_ECNTRL);
@@ -4419,7 +4684,9 @@ static int __maybe_unused fec_runtime_suspend(struct device *dev)
struct net_device *ndev = dev_get_drvdata(dev);
struct fec_enet_private *fep = netdev_priv(ndev);
+ clk_disable_unprepare(fep->clk_ahb);
clk_disable_unprepare(fep->clk_ipg);
+ release_bus_freq(BUS_FREQ_HIGH);
return 0;
}
@@ -4428,8 +4695,23 @@ static int __maybe_unused fec_runtime_resume(struct device *dev)
{
struct net_device *ndev = dev_get_drvdata(dev);
struct fec_enet_private *fep = netdev_priv(ndev);
+ int ret;
+
+ request_bus_freq(BUS_FREQ_HIGH);
+
+ ret = clk_prepare_enable(fep->clk_ahb);
+ if (ret)
+ return ret;
+ ret = clk_prepare_enable(fep->clk_ipg);
+ if (ret)
+ goto failed_clk_ipg;
+
+ return 0;
- return clk_prepare_enable(fep->clk_ipg);
+failed_clk_ipg:
+ clk_disable_unprepare(fep->clk_ahb);
+ release_bus_freq(BUS_FREQ_HIGH);
+ return ret;
}
static const struct dev_pm_ops fec_pm_ops = {
diff --git a/kernel/drivers/net/drivers/freescale/fec_ptp.c b/kernel/drivers/net/drivers/freescale/fec_ptp.c
index 6ebad3fac..bb148e99b 100644
--- a/kernel/drivers/net/drivers/freescale/fec_ptp.c
+++ b/kernel/drivers/net/drivers/freescale/fec_ptp.c
@@ -1,20 +1,8 @@
+// SPDX-License-Identifier: GPL-2.0
/*
* Fast Ethernet Controller (ENET) PTP driver for MX6x.
*
* Copyright (C) 2012 Freescale Semiconductor, Inc.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope 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.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
@@ -111,7 +99,6 @@ static int fec_ptp_enable_pps(struct fec_enet_private *fep, uint enable)
{
unsigned long flags;
u32 val, tempval;
- int inc;
struct timespec64 ts;
u64 ns;
val = 0;
@@ -126,7 +113,6 @@ static int fec_ptp_enable_pps(struct fec_enet_private *fep, uint enable)
fep->pps_channel = DEFAULT_PPS_CHANNEL;
fep->reload_period = PPS_OUPUT_RELOAD_PERIOD;
- inc = fep->ptp_inc;
spin_lock_irqsave(&fep->tmreg_lock, flags);
@@ -466,12 +452,6 @@ static int fec_ptp_enable(struct ptp_clock_info *ptp,
return -EOPNOTSUPP;
}
-/**
- * fec_ptp_hwtstamp_ioctl - control hardware time stamping
- * @ndev: pointer to net_device
- * @ifreq: ioctl data
- * @cmd: particular ioctl requested
- */
int fec_ptp_set(struct net_device *ndev, struct ifreq *ifr)
{
struct fec_enet_private *fep = netdev_priv(ndev);
@@ -549,6 +529,37 @@ static void fec_time_keep(struct work_struct *work)
schedule_delayed_work(&fep->time_keep, HZ);
}
+/* This function checks the pps event and reloads the timer compare counter. */
+static irqreturn_t fec_pps_interrupt(int irq, void *dev_id)
+{
+ struct net_device *ndev = dev_id;
+ struct fec_enet_private *fep = netdev_priv(ndev);
+ u32 val;
+ u8 channel = fep->pps_channel;
+ struct ptp_clock_event event;
+
+ val = readl(fep->hwp + FEC_TCSR(channel));
+ if (val & FEC_T_TF_MASK) {
+ /* Write the next next compare(not the next according the spec)
+ * value to the register
+ */
+ writel(fep->next_counter, fep->hwp + FEC_TCCR(channel));
+ do {
+ writel(val, fep->hwp + FEC_TCSR(channel));
+ } while (readl(fep->hwp + FEC_TCSR(channel)) & FEC_T_TF_MASK);
+
+ /* Update the counter; */
+ fep->next_counter = (fep->next_counter + fep->reload_period) &
+ fep->cc.mask;
+
+ event.type = PTP_CLOCK_PPS;
+ ptp_clock_event(fep->ptp_clock, &event);
+ return IRQ_HANDLED;
+ }
+
+ return IRQ_NONE;
+}
+
/**
* fec_ptp_init
* @ndev: The FEC network adapter
@@ -558,10 +569,12 @@ static void fec_time_keep(struct work_struct *work)
* cyclecounter init routine and exits.
*/
-void fec_ptp_init(struct platform_device *pdev)
+void fec_ptp_init(struct platform_device *pdev, int irq_idx)
{
struct net_device *ndev = platform_get_drvdata(pdev);
struct fec_enet_private *fep = netdev_priv(ndev);
+ int irq;
+ int ret;
fep->ptp_caps.owner = THIS_MODULE;
snprintf(fep->ptp_caps.name, 16, "fec ptp");
@@ -579,6 +592,10 @@ void fec_ptp_init(struct platform_device *pdev)
fep->ptp_caps.enable = fec_ptp_enable;
fep->cycle_speed = clk_get_rate(fep->clk_ptp);
+ if (!fep->cycle_speed) {
+ fep->cycle_speed = NSEC_PER_SEC;
+ dev_err(&fep->pdev->dev, "clk_ptp clock rate is zero\n");
+ }
fep->ptp_inc = NSEC_PER_SEC / fep->cycle_speed;
spin_lock_init(&fep->tmreg_lock);
@@ -587,10 +604,24 @@ void fec_ptp_init(struct platform_device *pdev)
INIT_DELAYED_WORK(&fep->time_keep, fec_time_keep);
+ irq = platform_get_irq_byname_optional(pdev, "pps");
+ if (irq < 0)
+ irq = platform_get_irq_optional(pdev, irq_idx);
+ /* Failure to get an irq is not fatal,
+ * only the PTP_CLOCK_PPS clock events should stop
+ */
+ if (irq >= 0) {
+ ret = devm_request_irq(&pdev->dev, irq, fec_pps_interrupt,
+ 0, pdev->name, ndev);
+ if (ret < 0)
+ dev_warn(&pdev->dev, "request for pps irq failed(%d)\n",
+ ret);
+ }
+
fep->ptp_clock = ptp_clock_register(&fep->ptp_caps, &pdev->dev);
if (IS_ERR(fep->ptp_clock)) {
fep->ptp_clock = NULL;
- pr_err("ptp_clock_register failed\n");
+ dev_err(&pdev->dev, "ptp_clock_register failed\n");
}
schedule_delayed_work(&fep->time_keep, HZ);
@@ -605,36 +636,3 @@ void fec_ptp_stop(struct platform_device *pdev)
if (fep->ptp_clock)
ptp_clock_unregister(fep->ptp_clock);
}
-
-/**
- * fec_ptp_check_pps_event
- * @fep: the fec_enet_private structure handle
- *
- * This function check the pps event and reload the timer compare counter.
- */
-uint fec_ptp_check_pps_event(struct fec_enet_private *fep)
-{
- u32 val;
- u8 channel = fep->pps_channel;
- struct ptp_clock_event event;
-
- val = readl(fep->hwp + FEC_TCSR(channel));
- if (val & FEC_T_TF_MASK) {
- /* Write the next next compare(not the next according the spec)
- * value to the register
- */
- writel(fep->next_counter, fep->hwp + FEC_TCCR(channel));
- do {
- writel(val, fep->hwp + FEC_TCSR(channel));
- } while (readl(fep->hwp + FEC_TCSR(channel)) & FEC_T_TF_MASK);
-
- /* Update the counter; */
- fep->next_counter = (fep->next_counter + fep->reload_period) & fep->cc.mask;
-
- event.type = PTP_CLOCK_PPS;
- ptp_clock_event(fep->ptp_clock, &event);
- return 1;
- }
-
- return 0;
-}
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 29/31] Kconfig : enable fec for ARM64 build
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (27 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 28/31] net/drivers: fec: update from linux kernel 5.4 and NXP I.MX8 Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 30/31] net/drivers: fec: fix dev_kfree_rtskb on wrong buffer Jean-Baptiste Trédez
` (3 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
Signed-off-by: Jean-Baptiste Trédez <jean-baptiste.tredez@alstefgroup.com>
---
kernel/drivers/net/drivers/Kconfig | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/drivers/net/drivers/Kconfig b/kernel/drivers/net/drivers/Kconfig
index c36533479..60889aa70 100644
--- a/kernel/drivers/net/drivers/Kconfig
+++ b/kernel/drivers/net/drivers/Kconfig
@@ -116,7 +116,7 @@ config XENO_DRIVERS_NET_DRV_SMC91111
depends on XENO_DRIVERS_NET
tristate "SMSC LAN91C111"
-if ARM
+if ARM || ARM64
config XENO_DRIVERS_NET_DRV_AT91_ETHER
depends on XENO_DRIVERS_NET && SOC_AT91RM9200
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 30/31] net/drivers: fec: fix dev_kfree_rtskb on wrong buffer
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (28 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 29/31] Kconfig : enable fec for ARM64 build Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-11 16:05 ` [PATCH 31/31] net/drivers: fec: remove 1ms latency on frames reception Jean-Baptiste Trédez
` (2 subsequent siblings)
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
Signed-off-by: Jean-Baptiste Trédez <jean-baptiste.tredez@alstefgroup.com>
---
kernel/drivers/net/drivers/freescale/fec_main.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/drivers/net/drivers/freescale/fec_main.c b/kernel/drivers/net/drivers/freescale/fec_main.c
index 62e8d5158..56ea27cf4 100644
--- a/kernel/drivers/net/drivers/freescale/fec_main.c
+++ b/kernel/drivers/net/drivers/freescale/fec_main.c
@@ -1145,7 +1145,7 @@ static void fec_enet_reset_skb(struct net_device *ndev)
for (j = 0; j < txq->bd.ring_size; j++) {
if (txq->tx_skbuff[j]) {
if (fep->rtnet.enabled)
- dev_kfree_rtskb(txq->tx_rtbuff[i]);
+ dev_kfree_rtskb(txq->tx_rtbuff[j]);
else
dev_kfree_skb_any(txq->tx_skbuff[j]);
txq->tx_skbuff[j] = NULL;
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH 31/31] net/drivers: fec: remove 1ms latency on frames reception
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (29 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 30/31] net/drivers: fec: fix dev_kfree_rtskb on wrong buffer Jean-Baptiste Trédez
@ 2021-05-11 16:05 ` Jean-Baptiste Trédez
2021-05-12 6:57 ` [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jan Kiszka
2021-06-04 9:14 ` Jan Kiszka
32 siblings, 0 replies; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-05-11 16:05 UTC (permalink / raw)
To: xenomai
From: abouvet <arnaud.bouvet@alstefgroup.com>
Signed-off-by: Arnaud Bouvet <arnaud.bouvet@alstefgroup.com>
Signed-off-by: Jean-Baptiste Trédez <jean-baptiste.tredez@alstefgroup.com>
---
kernel/drivers/net/drivers/freescale/fec.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/kernel/drivers/net/drivers/freescale/fec.h b/kernel/drivers/net/drivers/freescale/fec.h
index 5ab51701d..ba177fcf9 100644
--- a/kernel/drivers/net/drivers/freescale/fec.h
+++ b/kernel/drivers/net/drivers/freescale/fec.h
@@ -392,7 +392,7 @@ struct bufdesc_ex {
#define FEC_ITR_ICFT(X) (((X) & 0xff) << 20)
#define FEC_ITR_ICTT(X) ((X) & 0xffff)
#define FEC_ITR_ICFT_DEFAULT 200 /* Set 200 frame count threshold */
-#define FEC_ITR_ICTT_DEFAULT 1000 /* Set 1000us timer threshold */
+#define FEC_ITR_ICTT_DEFAULT 10 /* Set 10 us timer threshold */
#define FEC_VLAN_TAG_LEN 0x04
#define FEC_ETHTYPE_LEN 0x02
--
2.17.1
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (30 preceding siblings ...)
2021-05-11 16:05 ` [PATCH 31/31] net/drivers: fec: remove 1ms latency on frames reception Jean-Baptiste Trédez
@ 2021-05-12 6:57 ` Jan Kiszka
2021-05-12 9:52 ` Jean-Baptiste Tredez
2021-06-04 9:14 ` Jan Kiszka
32 siblings, 1 reply; 40+ messages in thread
From: Jan Kiszka @ 2021-05-12 6:57 UTC (permalink / raw)
To: Jean-Baptiste Trédez, xenomai
On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
>
> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with updated driver for 4.18.85 kernel
> Patch 28 to 29 : update driver for 5.4 kernel and add I.MX8 support
> Patch 30 : bugfix on fec_enet_reset_skb
> Patch 31 : reduce latency
>
>
> Christophe Carton (1):
> utils/net: ping: display min and average round-trip time
>
> Florian Bezdeka (1):
> cobalt uapi: Introducing new feature flag for time64 availability
>
Seems your baseline was off. Please check that you were really sending
from the right branch.
Jan
> Gilles Chanteperdrix (17):
> net/stack: plan for merging private device flags with
> netdev_priv_flags
> net/stack: add multicast support
> utils/net: rtifconfig: display device name untruncated
> net/stack: add support for VLAN filtering
> utils/net: add VLAN filter configuration tool
> net/udp: allow retrieving irq timestamp with SIOCGSTAMP ioctl
> net/udp sendmsg: do not return an error if dest addr is null
> net/stack: rtskb: increase buffer size
> net/stack: manager: ratelimit printk when dropping buffers
> net/ipv4: icmp: forward unused packets to proxy
> net/drivers: e1000e: enable multicast
> net/drivers: e1000e: enable VLAN filtering
> net/drivers: e1000e: add netdevice stats
> net/drivers: igb: enable multicast
> net/drivers: igb: enable VLAN filtering
> demo/net: add rtnet tests
> net/stack: increase maximum number of ethernet devices
>
> Jean-Baptiste Trédez (3):
> net/drivers: fec: update from linux kernel 5.4 and NXP I.MX8
> Kconfig : enable fec for ARM64 build
> net/drivers: fec: fix dev_kfree_rtskb on wrong buffer
>
> Philippe Gerum (8):
> net/drivers: fec: rebase over original driver from kernel 4.14.85
> net/drivers: fec: enable multicast
> demo: restrict net/ to cobalt build
> net/ipv4: route: fix counting of allocated net routes
> net/ipv4: route: handle default net route
> utils/net: rtroute: add/del default route
> net/ipv4: sock: handle SO_REUSEADDR for SOCK_DGRAM gracefully
> net/stack: igmp: resolve default multicast interface
>
> Arnaud Bouvet (1):
> net/drivers: fec: remove 1ms latency on frames reception
>
> configure.ac | 1 +
> demo/Makefile.am | 4 +
> demo/net/Makefile.am | 78 +
> demo/net/mcast-receiver.c | 205 +
> demo/net/mcast-sender.c | 151 +
> demo/net/raw-ethernet.c | 100 +
> demo/net/rtt-mcast-measure.c | 210 +
> demo/net/rtt-mcast-responder.c | 109 +
> demo/net/rtt-responder.c | 193 +
> demo/net/rtt-sender.c | 341 ++
> demo/net/rttcp-client.c | 212 +
> demo/net/rttcp-server.c | 181 +
> demo/net/udp-send.c | 136 +
> include/cobalt/uapi/asm-generic/features.h | 6 +-
> .../arm64/include/asm/xenomai/uapi/features.h | 1 +
> .../include/asm/xenomai/uapi/features.h | 1 +
> .../x86/include/asm/xenomai/uapi/features.h | 1 +
> kernel/drivers/net/addons/cap.c | 46 +-
> kernel/drivers/net/doc/README.routing | 22 +
> kernel/drivers/net/doc/README.rtnetproxy | 6 +-
> kernel/drivers/net/drivers/Kconfig | 11 +-
> kernel/drivers/net/drivers/Makefile | 6 +-
> kernel/drivers/net/drivers/e1000e/e1000.h | 7 +-
> kernel/drivers/net/drivers/e1000e/hw.h | 2 +-
> kernel/drivers/net/drivers/e1000e/lib.c | 7 +-
> kernel/drivers/net/drivers/e1000e/netdev.c | 266 +-
> kernel/drivers/net/drivers/fec.c | 1859 -------
> kernel/drivers/net/drivers/freescale/Makefile | 5 +
> kernel/drivers/net/drivers/freescale/fec.h | 642 +++
> .../drivers/net/drivers/freescale/fec_main.c | 4736 +++++++++++++++++
> .../drivers/net/drivers/freescale/fec_ptp.c | 638 +++
> kernel/drivers/net/drivers/igb/e1000_mac.c | 6 +-
> kernel/drivers/net/drivers/igb/e1000_mac.h | 2 +-
> kernel/drivers/net/drivers/igb/igb_main.c | 53 +-
> kernel/drivers/net/drivers/rt_fec.h | 153 -
> kernel/drivers/net/stack/Kconfig | 8 +
> kernel/drivers/net/stack/Makefile | 2 +
> kernel/drivers/net/stack/include/ipv4/arp.h | 3 +
> kernel/drivers/net/stack/include/ipv4/igmp.h | 102 +
> .../drivers/net/stack/include/ipv4/protocol.h | 1 +
> kernel/drivers/net/stack/include/rtdev.h | 47 +-
> kernel/drivers/net/stack/include/rtif_vlan.h | 105 +
> kernel/drivers/net/stack/include/rtnet_port.h | 6 +-
> .../drivers/net/stack/include/rtnet_socket.h | 6 +
> kernel/drivers/net/stack/include/rtskb.h | 4 +-
> kernel/drivers/net/stack/include/rtvlan.h | 25 +
> kernel/drivers/net/stack/ipv4/Kconfig | 7 +
> kernel/drivers/net/stack/ipv4/Makefile | 1 +
> kernel/drivers/net/stack/ipv4/af_inet.c | 5 +
> kernel/drivers/net/stack/ipv4/arp.c | 26 +
> kernel/drivers/net/stack/ipv4/icmp.c | 14 +
> kernel/drivers/net/stack/ipv4/igmp.c | 624 +++
> kernel/drivers/net/stack/ipv4/ip_output.c | 13 +-
> kernel/drivers/net/stack/ipv4/ip_sock.c | 73 +-
> kernel/drivers/net/stack/ipv4/protocol.c | 17 +
> kernel/drivers/net/stack/ipv4/route.c | 56 +-
> kernel/drivers/net/stack/ipv4/tcp/tcp.c | 2 +-
> kernel/drivers/net/stack/ipv4/udp/udp.c | 53 +-
> kernel/drivers/net/stack/rtdev.c | 214 +
> kernel/drivers/net/stack/rtnet_chrdev.c | 8 +-
> kernel/drivers/net/stack/rtnet_module.c | 5 +
> kernel/drivers/net/stack/socket.c | 17 +-
> kernel/drivers/net/stack/stack_mgr.c | 2 +-
> kernel/drivers/net/stack/vlan.c | 725 +++
> utils/net/Makefile.am | 1 +
> utils/net/rtifconfig.c | 2 +-
> utils/net/rtping.c | 16 +-
> utils/net/rtroute.c | 39 +-
> utils/net/rtvconfig.c | 257 +
> 69 files changed, 10741 insertions(+), 2142 deletions(-)
> create mode 100644 demo/net/Makefile.am
> create mode 100644 demo/net/mcast-receiver.c
> create mode 100644 demo/net/mcast-sender.c
> create mode 100644 demo/net/raw-ethernet.c
> create mode 100644 demo/net/rtt-mcast-measure.c
> create mode 100644 demo/net/rtt-mcast-responder.c
> create mode 100644 demo/net/rtt-responder.c
> create mode 100644 demo/net/rtt-sender.c
> create mode 100644 demo/net/rttcp-client.c
> create mode 100644 demo/net/rttcp-server.c
> create mode 100644 demo/net/udp-send.c
> delete mode 100644 kernel/drivers/net/drivers/fec.c
> create mode 100644 kernel/drivers/net/drivers/freescale/Makefile
> create mode 100644 kernel/drivers/net/drivers/freescale/fec.h
> create mode 100644 kernel/drivers/net/drivers/freescale/fec_main.c
> create mode 100644 kernel/drivers/net/drivers/freescale/fec_ptp.c
> delete mode 100644 kernel/drivers/net/drivers/rt_fec.h
> create mode 100644 kernel/drivers/net/stack/include/ipv4/igmp.h
> create mode 100644 kernel/drivers/net/stack/include/rtif_vlan.h
> create mode 100644 kernel/drivers/net/stack/include/rtvlan.h
> create mode 100644 kernel/drivers/net/stack/ipv4/igmp.c
> create mode 100644 kernel/drivers/net/stack/vlan.c
> create mode 100644 utils/net/rtvconfig.c
>
--
Siemens AG, T RDA IOT
Corporate Competence Center Embedded Linux
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-05-12 6:57 ` [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jan Kiszka
@ 2021-05-12 9:52 ` Jean-Baptiste Tredez
2021-05-17 16:06 ` Jan Kiszka
0 siblings, 1 reply; 40+ messages in thread
From: Jean-Baptiste Tredez @ 2021-05-12 9:52 UTC (permalink / raw)
To: Jan Kiszka, xenomai
Le 12/05/2021 à 08:57, Jan Kiszka a écrit :
> On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
>> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
>>
>> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with updated driver for 4.18.85 kernel
>> Patch 28 to 29 : update driver for 5.4 kernel and add I.MX8 support
>> Patch 30 : bugfix on fec_enet_reset_skb
>> Patch 31 : reduce latency
>>
>>
>> Christophe Carton (1):
>> utils/net: ping: display min and average round-trip time
>>
>> Florian Bezdeka (1):
>> cobalt uapi: Introducing new feature flag for time64 availability
>>
> Seems your baseline was off. Please check that you were really sending
> from the right branch.
>
> Jan
The patch "[PATCH 01/31] cobalt uapi: Introducing new feature flag for
time64 availability" was kept when i rebased rtnet-mcast+vlan branch on
next. I can resend the whole set without it if needed.
Jean-Baptiste
>
>> Gilles Chanteperdrix (17):
>> net/stack: plan for merging private device flags with
>> netdev_priv_flags
>> net/stack: add multicast support
>> utils/net: rtifconfig: display device name untruncated
>> net/stack: add support for VLAN filtering
>> utils/net: add VLAN filter configuration tool
>> net/udp: allow retrieving irq timestamp with SIOCGSTAMP ioctl
>> net/udp sendmsg: do not return an error if dest addr is null
>> net/stack: rtskb: increase buffer size
>> net/stack: manager: ratelimit printk when dropping buffers
>> net/ipv4: icmp: forward unused packets to proxy
>> net/drivers: e1000e: enable multicast
>> net/drivers: e1000e: enable VLAN filtering
>> net/drivers: e1000e: add netdevice stats
>> net/drivers: igb: enable multicast
>> net/drivers: igb: enable VLAN filtering
>> demo/net: add rtnet tests
>> net/stack: increase maximum number of ethernet devices
>>
>> Jean-Baptiste Trédez (3):
>> net/drivers: fec: update from linux kernel 5.4 and NXP I.MX8
>> Kconfig : enable fec for ARM64 build
>> net/drivers: fec: fix dev_kfree_rtskb on wrong buffer
>>
>> Philippe Gerum (8):
>> net/drivers: fec: rebase over original driver from kernel 4.14.85
>> net/drivers: fec: enable multicast
>> demo: restrict net/ to cobalt build
>> net/ipv4: route: fix counting of allocated net routes
>> net/ipv4: route: handle default net route
>> utils/net: rtroute: add/del default route
>> net/ipv4: sock: handle SO_REUSEADDR for SOCK_DGRAM gracefully
>> net/stack: igmp: resolve default multicast interface
>>
>> Arnaud Bouvet (1):
>> net/drivers: fec: remove 1ms latency on frames reception
>>
>> configure.ac | 1 +
>> demo/Makefile.am | 4 +
>> demo/net/Makefile.am | 78 +
>> demo/net/mcast-receiver.c | 205 +
>> demo/net/mcast-sender.c | 151 +
>> demo/net/raw-ethernet.c | 100 +
>> demo/net/rtt-mcast-measure.c | 210 +
>> demo/net/rtt-mcast-responder.c | 109 +
>> demo/net/rtt-responder.c | 193 +
>> demo/net/rtt-sender.c | 341 ++
>> demo/net/rttcp-client.c | 212 +
>> demo/net/rttcp-server.c | 181 +
>> demo/net/udp-send.c | 136 +
>> include/cobalt/uapi/asm-generic/features.h | 6 +-
>> .../arm64/include/asm/xenomai/uapi/features.h | 1 +
>> .../include/asm/xenomai/uapi/features.h | 1 +
>> .../x86/include/asm/xenomai/uapi/features.h | 1 +
>> kernel/drivers/net/addons/cap.c | 46 +-
>> kernel/drivers/net/doc/README.routing | 22 +
>> kernel/drivers/net/doc/README.rtnetproxy | 6 +-
>> kernel/drivers/net/drivers/Kconfig | 11 +-
>> kernel/drivers/net/drivers/Makefile | 6 +-
>> kernel/drivers/net/drivers/e1000e/e1000.h | 7 +-
>> kernel/drivers/net/drivers/e1000e/hw.h | 2 +-
>> kernel/drivers/net/drivers/e1000e/lib.c | 7 +-
>> kernel/drivers/net/drivers/e1000e/netdev.c | 266 +-
>> kernel/drivers/net/drivers/fec.c | 1859 -------
>> kernel/drivers/net/drivers/freescale/Makefile | 5 +
>> kernel/drivers/net/drivers/freescale/fec.h | 642 +++
>> .../drivers/net/drivers/freescale/fec_main.c | 4736 +++++++++++++++++
>> .../drivers/net/drivers/freescale/fec_ptp.c | 638 +++
>> kernel/drivers/net/drivers/igb/e1000_mac.c | 6 +-
>> kernel/drivers/net/drivers/igb/e1000_mac.h | 2 +-
>> kernel/drivers/net/drivers/igb/igb_main.c | 53 +-
>> kernel/drivers/net/drivers/rt_fec.h | 153 -
>> kernel/drivers/net/stack/Kconfig | 8 +
>> kernel/drivers/net/stack/Makefile | 2 +
>> kernel/drivers/net/stack/include/ipv4/arp.h | 3 +
>> kernel/drivers/net/stack/include/ipv4/igmp.h | 102 +
>> .../drivers/net/stack/include/ipv4/protocol.h | 1 +
>> kernel/drivers/net/stack/include/rtdev.h | 47 +-
>> kernel/drivers/net/stack/include/rtif_vlan.h | 105 +
>> kernel/drivers/net/stack/include/rtnet_port.h | 6 +-
>> .../drivers/net/stack/include/rtnet_socket.h | 6 +
>> kernel/drivers/net/stack/include/rtskb.h | 4 +-
>> kernel/drivers/net/stack/include/rtvlan.h | 25 +
>> kernel/drivers/net/stack/ipv4/Kconfig | 7 +
>> kernel/drivers/net/stack/ipv4/Makefile | 1 +
>> kernel/drivers/net/stack/ipv4/af_inet.c | 5 +
>> kernel/drivers/net/stack/ipv4/arp.c | 26 +
>> kernel/drivers/net/stack/ipv4/icmp.c | 14 +
>> kernel/drivers/net/stack/ipv4/igmp.c | 624 +++
>> kernel/drivers/net/stack/ipv4/ip_output.c | 13 +-
>> kernel/drivers/net/stack/ipv4/ip_sock.c | 73 +-
>> kernel/drivers/net/stack/ipv4/protocol.c | 17 +
>> kernel/drivers/net/stack/ipv4/route.c | 56 +-
>> kernel/drivers/net/stack/ipv4/tcp/tcp.c | 2 +-
>> kernel/drivers/net/stack/ipv4/udp/udp.c | 53 +-
>> kernel/drivers/net/stack/rtdev.c | 214 +
>> kernel/drivers/net/stack/rtnet_chrdev.c | 8 +-
>> kernel/drivers/net/stack/rtnet_module.c | 5 +
>> kernel/drivers/net/stack/socket.c | 17 +-
>> kernel/drivers/net/stack/stack_mgr.c | 2 +-
>> kernel/drivers/net/stack/vlan.c | 725 +++
>> utils/net/Makefile.am | 1 +
>> utils/net/rtifconfig.c | 2 +-
>> utils/net/rtping.c | 16 +-
>> utils/net/rtroute.c | 39 +-
>> utils/net/rtvconfig.c | 257 +
>> 69 files changed, 10741 insertions(+), 2142 deletions(-)
>> create mode 100644 demo/net/Makefile.am
>> create mode 100644 demo/net/mcast-receiver.c
>> create mode 100644 demo/net/mcast-sender.c
>> create mode 100644 demo/net/raw-ethernet.c
>> create mode 100644 demo/net/rtt-mcast-measure.c
>> create mode 100644 demo/net/rtt-mcast-responder.c
>> create mode 100644 demo/net/rtt-responder.c
>> create mode 100644 demo/net/rtt-sender.c
>> create mode 100644 demo/net/rttcp-client.c
>> create mode 100644 demo/net/rttcp-server.c
>> create mode 100644 demo/net/udp-send.c
>> delete mode 100644 kernel/drivers/net/drivers/fec.c
>> create mode 100644 kernel/drivers/net/drivers/freescale/Makefile
>> create mode 100644 kernel/drivers/net/drivers/freescale/fec.h
>> create mode 100644 kernel/drivers/net/drivers/freescale/fec_main.c
>> create mode 100644 kernel/drivers/net/drivers/freescale/fec_ptp.c
>> delete mode 100644 kernel/drivers/net/drivers/rt_fec.h
>> create mode 100644 kernel/drivers/net/stack/include/ipv4/igmp.h
>> create mode 100644 kernel/drivers/net/stack/include/rtif_vlan.h
>> create mode 100644 kernel/drivers/net/stack/include/rtvlan.h
>> create mode 100644 kernel/drivers/net/stack/ipv4/igmp.c
>> create mode 100644 kernel/drivers/net/stack/vlan.c
>> create mode 100644 utils/net/rtvconfig.c
>>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-05-12 9:52 ` Jean-Baptiste Tredez
@ 2021-05-17 16:06 ` Jan Kiszka
0 siblings, 0 replies; 40+ messages in thread
From: Jan Kiszka @ 2021-05-17 16:06 UTC (permalink / raw)
To: Jean-Baptiste Tredez, xenomai
On 12.05.21 11:52, Jean-Baptiste Tredez wrote:
>
> Le 12/05/2021 à 08:57, Jan Kiszka a écrit :
>> On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
>>> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8
>>> support
>>>
>>> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with
>>> updated driver for 4.18.85 kernel
>>> Patch 28 to 29 : update driver for 5.4 kernel and add I.MX8 support
>>> Patch 30 : bugfix on fec_enet_reset_skb
>>> Patch 31 : reduce latency
>>>
>>>
>>> Christophe Carton (1):
>>> utils/net: ping: display min and average round-trip time
>>>
>>> Florian Bezdeka (1):
>>> cobalt uapi: Introducing new feature flag for time64 availability
>>>
>> Seems your baseline was off. Please check that you were really sending
>> from the right branch.
>>
>> Jan
>
> The patch "[PATCH 01/31] cobalt uapi: Introducing new feature flag for
> time64 availability" was kept when i rebased rtnet-mcast+vlan branch on
> next. I can resend the whole set without it if needed.
>
Thanks, understood. Let me go through these first. May still take a
while, too much stuff on the table ATM.
Jan
--
Siemens AG, T RDA IOT
Corporate Competence Center Embedded Linux
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-05-11 16:05 [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jean-Baptiste Trédez
` (31 preceding siblings ...)
2021-05-12 6:57 ` [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support Jan Kiszka
@ 2021-06-04 9:14 ` Jan Kiszka
2021-06-12 17:00 ` Jean-Baptiste Trédez
32 siblings, 1 reply; 40+ messages in thread
From: Jan Kiszka @ 2021-06-04 9:14 UTC (permalink / raw)
To: Jean-Baptiste Trédez, xenomai, Philippe Gerum
On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
>
> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with updated driver for 4.18.85 kernel
May I assume that submission of this branch has been coordinated between
you two, and Philippe considers them ready as well? Some patches lack
descriptions, and maybe I will find more things that should be adjusted
first. Will you address them then, Jean-Baptiste?
Jan
> Patch 28 to 29 : update driver for 5.4 kernel and add I.MX8 support
> Patch 30 : bugfix on fec_enet_reset_skb
> Patch 31 : reduce latency
>
>
> Christophe Carton (1):
> utils/net: ping: display min and average round-trip time
>
> Florian Bezdeka (1):
> cobalt uapi: Introducing new feature flag for time64 availability
>
> Gilles Chanteperdrix (17):
> net/stack: plan for merging private device flags with
> netdev_priv_flags
> net/stack: add multicast support
> utils/net: rtifconfig: display device name untruncated
> net/stack: add support for VLAN filtering
> utils/net: add VLAN filter configuration tool
> net/udp: allow retrieving irq timestamp with SIOCGSTAMP ioctl
> net/udp sendmsg: do not return an error if dest addr is null
> net/stack: rtskb: increase buffer size
> net/stack: manager: ratelimit printk when dropping buffers
> net/ipv4: icmp: forward unused packets to proxy
> net/drivers: e1000e: enable multicast
> net/drivers: e1000e: enable VLAN filtering
> net/drivers: e1000e: add netdevice stats
> net/drivers: igb: enable multicast
> net/drivers: igb: enable VLAN filtering
> demo/net: add rtnet tests
> net/stack: increase maximum number of ethernet devices
>
> Jean-Baptiste Trédez (3):
> net/drivers: fec: update from linux kernel 5.4 and NXP I.MX8
> Kconfig : enable fec for ARM64 build
> net/drivers: fec: fix dev_kfree_rtskb on wrong buffer
>
> Philippe Gerum (8):
> net/drivers: fec: rebase over original driver from kernel 4.14.85
> net/drivers: fec: enable multicast
> demo: restrict net/ to cobalt build
> net/ipv4: route: fix counting of allocated net routes
> net/ipv4: route: handle default net route
> utils/net: rtroute: add/del default route
> net/ipv4: sock: handle SO_REUSEADDR for SOCK_DGRAM gracefully
> net/stack: igmp: resolve default multicast interface
>
> Arnaud Bouvet (1):
> net/drivers: fec: remove 1ms latency on frames reception
>
> configure.ac | 1 +
> demo/Makefile.am | 4 +
> demo/net/Makefile.am | 78 +
> demo/net/mcast-receiver.c | 205 +
> demo/net/mcast-sender.c | 151 +
> demo/net/raw-ethernet.c | 100 +
> demo/net/rtt-mcast-measure.c | 210 +
> demo/net/rtt-mcast-responder.c | 109 +
> demo/net/rtt-responder.c | 193 +
> demo/net/rtt-sender.c | 341 ++
> demo/net/rttcp-client.c | 212 +
> demo/net/rttcp-server.c | 181 +
> demo/net/udp-send.c | 136 +
> include/cobalt/uapi/asm-generic/features.h | 6 +-
> .../arm64/include/asm/xenomai/uapi/features.h | 1 +
> .../include/asm/xenomai/uapi/features.h | 1 +
> .../x86/include/asm/xenomai/uapi/features.h | 1 +
> kernel/drivers/net/addons/cap.c | 46 +-
> kernel/drivers/net/doc/README.routing | 22 +
> kernel/drivers/net/doc/README.rtnetproxy | 6 +-
> kernel/drivers/net/drivers/Kconfig | 11 +-
> kernel/drivers/net/drivers/Makefile | 6 +-
> kernel/drivers/net/drivers/e1000e/e1000.h | 7 +-
> kernel/drivers/net/drivers/e1000e/hw.h | 2 +-
> kernel/drivers/net/drivers/e1000e/lib.c | 7 +-
> kernel/drivers/net/drivers/e1000e/netdev.c | 266 +-
> kernel/drivers/net/drivers/fec.c | 1859 -------
> kernel/drivers/net/drivers/freescale/Makefile | 5 +
> kernel/drivers/net/drivers/freescale/fec.h | 642 +++
> .../drivers/net/drivers/freescale/fec_main.c | 4736 +++++++++++++++++
> .../drivers/net/drivers/freescale/fec_ptp.c | 638 +++
> kernel/drivers/net/drivers/igb/e1000_mac.c | 6 +-
> kernel/drivers/net/drivers/igb/e1000_mac.h | 2 +-
> kernel/drivers/net/drivers/igb/igb_main.c | 53 +-
> kernel/drivers/net/drivers/rt_fec.h | 153 -
> kernel/drivers/net/stack/Kconfig | 8 +
> kernel/drivers/net/stack/Makefile | 2 +
> kernel/drivers/net/stack/include/ipv4/arp.h | 3 +
> kernel/drivers/net/stack/include/ipv4/igmp.h | 102 +
> .../drivers/net/stack/include/ipv4/protocol.h | 1 +
> kernel/drivers/net/stack/include/rtdev.h | 47 +-
> kernel/drivers/net/stack/include/rtif_vlan.h | 105 +
> kernel/drivers/net/stack/include/rtnet_port.h | 6 +-
> .../drivers/net/stack/include/rtnet_socket.h | 6 +
> kernel/drivers/net/stack/include/rtskb.h | 4 +-
> kernel/drivers/net/stack/include/rtvlan.h | 25 +
> kernel/drivers/net/stack/ipv4/Kconfig | 7 +
> kernel/drivers/net/stack/ipv4/Makefile | 1 +
> kernel/drivers/net/stack/ipv4/af_inet.c | 5 +
> kernel/drivers/net/stack/ipv4/arp.c | 26 +
> kernel/drivers/net/stack/ipv4/icmp.c | 14 +
> kernel/drivers/net/stack/ipv4/igmp.c | 624 +++
> kernel/drivers/net/stack/ipv4/ip_output.c | 13 +-
> kernel/drivers/net/stack/ipv4/ip_sock.c | 73 +-
> kernel/drivers/net/stack/ipv4/protocol.c | 17 +
> kernel/drivers/net/stack/ipv4/route.c | 56 +-
> kernel/drivers/net/stack/ipv4/tcp/tcp.c | 2 +-
> kernel/drivers/net/stack/ipv4/udp/udp.c | 53 +-
> kernel/drivers/net/stack/rtdev.c | 214 +
> kernel/drivers/net/stack/rtnet_chrdev.c | 8 +-
> kernel/drivers/net/stack/rtnet_module.c | 5 +
> kernel/drivers/net/stack/socket.c | 17 +-
> kernel/drivers/net/stack/stack_mgr.c | 2 +-
> kernel/drivers/net/stack/vlan.c | 725 +++
> utils/net/Makefile.am | 1 +
> utils/net/rtifconfig.c | 2 +-
> utils/net/rtping.c | 16 +-
> utils/net/rtroute.c | 39 +-
> utils/net/rtvconfig.c | 257 +
> 69 files changed, 10741 insertions(+), 2142 deletions(-)
> create mode 100644 demo/net/Makefile.am
> create mode 100644 demo/net/mcast-receiver.c
> create mode 100644 demo/net/mcast-sender.c
> create mode 100644 demo/net/raw-ethernet.c
> create mode 100644 demo/net/rtt-mcast-measure.c
> create mode 100644 demo/net/rtt-mcast-responder.c
> create mode 100644 demo/net/rtt-responder.c
> create mode 100644 demo/net/rtt-sender.c
> create mode 100644 demo/net/rttcp-client.c
> create mode 100644 demo/net/rttcp-server.c
> create mode 100644 demo/net/udp-send.c
> delete mode 100644 kernel/drivers/net/drivers/fec.c
> create mode 100644 kernel/drivers/net/drivers/freescale/Makefile
> create mode 100644 kernel/drivers/net/drivers/freescale/fec.h
> create mode 100644 kernel/drivers/net/drivers/freescale/fec_main.c
> create mode 100644 kernel/drivers/net/drivers/freescale/fec_ptp.c
> delete mode 100644 kernel/drivers/net/drivers/rt_fec.h
> create mode 100644 kernel/drivers/net/stack/include/ipv4/igmp.h
> create mode 100644 kernel/drivers/net/stack/include/rtif_vlan.h
> create mode 100644 kernel/drivers/net/stack/include/rtvlan.h
> create mode 100644 kernel/drivers/net/stack/ipv4/igmp.c
> create mode 100644 kernel/drivers/net/stack/vlan.c
> create mode 100644 utils/net/rtvconfig.c
>
--
Siemens AG, T RDA IOT
Corporate Competence Center Embedded Linux
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-06-04 9:14 ` Jan Kiszka
@ 2021-06-12 17:00 ` Jean-Baptiste Trédez
2021-06-13 17:13 ` Jan Kiszka
0 siblings, 1 reply; 40+ messages in thread
From: Jean-Baptiste Trédez @ 2021-06-12 17:00 UTC (permalink / raw)
To: Jan Kiszka, xenomai, Philippe Gerum
Le 04/06/2021 à 11:14, Jan Kiszka a écrit :
> On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
>> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
>>
>> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with updated driver for 4.18.85 kernel
> May I assume that submission of this branch has been coordinated between
> you two, and Philippe considers them ready as well? Some patches lack
> descriptions, and maybe I will find more things that should be adjusted
> first. Will you address them then, Jean-Baptiste?
>
> Jan
I rebased the work on fec driver with the rtnet-mcast+vlan branch on
next, as suggested by Philippe, and added separated patch (patch 30 and
31) to show what i would like to change on previous work and added patch
28 and 29 to upgrade to 5.4.x kernels.
I will address your findings on the fec driver and test it with a 5.4
kernel on our target. I am not very familiar with the multicast and vlan
work, if the work is not ready, i can submit the fec driver without the
mcast+vlan work.
Jean-Baptiste
>
>> Patch 28 to 29 : update driver for 5.4 kernel and add I.MX8 support
>> Patch 30 : bugfix on fec_enet_reset_skb
>> Patch 31 : reduce latency
>>
>>
>> Christophe Carton (1):
>> utils/net: ping: display min and average round-trip time
>>
>> Florian Bezdeka (1):
>> cobalt uapi: Introducing new feature flag for time64 availability
>>
>> Gilles Chanteperdrix (17):
>> net/stack: plan for merging private device flags with
>> netdev_priv_flags
>> net/stack: add multicast support
>> utils/net: rtifconfig: display device name untruncated
>> net/stack: add support for VLAN filtering
>> utils/net: add VLAN filter configuration tool
>> net/udp: allow retrieving irq timestamp with SIOCGSTAMP ioctl
>> net/udp sendmsg: do not return an error if dest addr is null
>> net/stack: rtskb: increase buffer size
>> net/stack: manager: ratelimit printk when dropping buffers
>> net/ipv4: icmp: forward unused packets to proxy
>> net/drivers: e1000e: enable multicast
>> net/drivers: e1000e: enable VLAN filtering
>> net/drivers: e1000e: add netdevice stats
>> net/drivers: igb: enable multicast
>> net/drivers: igb: enable VLAN filtering
>> demo/net: add rtnet tests
>> net/stack: increase maximum number of ethernet devices
>>
>> Jean-Baptiste Trédez (3):
>> net/drivers: fec: update from linux kernel 5.4 and NXP I.MX8
>> Kconfig : enable fec for ARM64 build
>> net/drivers: fec: fix dev_kfree_rtskb on wrong buffer
>>
>> Philippe Gerum (8):
>> net/drivers: fec: rebase over original driver from kernel 4.14.85
>> net/drivers: fec: enable multicast
>> demo: restrict net/ to cobalt build
>> net/ipv4: route: fix counting of allocated net routes
>> net/ipv4: route: handle default net route
>> utils/net: rtroute: add/del default route
>> net/ipv4: sock: handle SO_REUSEADDR for SOCK_DGRAM gracefully
>> net/stack: igmp: resolve default multicast interface
>>
>> Arnaud Bouvet (1):
>> net/drivers: fec: remove 1ms latency on frames reception
>>
>> configure.ac | 1 +
>> demo/Makefile.am | 4 +
>> demo/net/Makefile.am | 78 +
>> demo/net/mcast-receiver.c | 205 +
>> demo/net/mcast-sender.c | 151 +
>> demo/net/raw-ethernet.c | 100 +
>> demo/net/rtt-mcast-measure.c | 210 +
>> demo/net/rtt-mcast-responder.c | 109 +
>> demo/net/rtt-responder.c | 193 +
>> demo/net/rtt-sender.c | 341 ++
>> demo/net/rttcp-client.c | 212 +
>> demo/net/rttcp-server.c | 181 +
>> demo/net/udp-send.c | 136 +
>> include/cobalt/uapi/asm-generic/features.h | 6 +-
>> .../arm64/include/asm/xenomai/uapi/features.h | 1 +
>> .../include/asm/xenomai/uapi/features.h | 1 +
>> .../x86/include/asm/xenomai/uapi/features.h | 1 +
>> kernel/drivers/net/addons/cap.c | 46 +-
>> kernel/drivers/net/doc/README.routing | 22 +
>> kernel/drivers/net/doc/README.rtnetproxy | 6 +-
>> kernel/drivers/net/drivers/Kconfig | 11 +-
>> kernel/drivers/net/drivers/Makefile | 6 +-
>> kernel/drivers/net/drivers/e1000e/e1000.h | 7 +-
>> kernel/drivers/net/drivers/e1000e/hw.h | 2 +-
>> kernel/drivers/net/drivers/e1000e/lib.c | 7 +-
>> kernel/drivers/net/drivers/e1000e/netdev.c | 266 +-
>> kernel/drivers/net/drivers/fec.c | 1859 -------
>> kernel/drivers/net/drivers/freescale/Makefile | 5 +
>> kernel/drivers/net/drivers/freescale/fec.h | 642 +++
>> .../drivers/net/drivers/freescale/fec_main.c | 4736 +++++++++++++++++
>> .../drivers/net/drivers/freescale/fec_ptp.c | 638 +++
>> kernel/drivers/net/drivers/igb/e1000_mac.c | 6 +-
>> kernel/drivers/net/drivers/igb/e1000_mac.h | 2 +-
>> kernel/drivers/net/drivers/igb/igb_main.c | 53 +-
>> kernel/drivers/net/drivers/rt_fec.h | 153 -
>> kernel/drivers/net/stack/Kconfig | 8 +
>> kernel/drivers/net/stack/Makefile | 2 +
>> kernel/drivers/net/stack/include/ipv4/arp.h | 3 +
>> kernel/drivers/net/stack/include/ipv4/igmp.h | 102 +
>> .../drivers/net/stack/include/ipv4/protocol.h | 1 +
>> kernel/drivers/net/stack/include/rtdev.h | 47 +-
>> kernel/drivers/net/stack/include/rtif_vlan.h | 105 +
>> kernel/drivers/net/stack/include/rtnet_port.h | 6 +-
>> .../drivers/net/stack/include/rtnet_socket.h | 6 +
>> kernel/drivers/net/stack/include/rtskb.h | 4 +-
>> kernel/drivers/net/stack/include/rtvlan.h | 25 +
>> kernel/drivers/net/stack/ipv4/Kconfig | 7 +
>> kernel/drivers/net/stack/ipv4/Makefile | 1 +
>> kernel/drivers/net/stack/ipv4/af_inet.c | 5 +
>> kernel/drivers/net/stack/ipv4/arp.c | 26 +
>> kernel/drivers/net/stack/ipv4/icmp.c | 14 +
>> kernel/drivers/net/stack/ipv4/igmp.c | 624 +++
>> kernel/drivers/net/stack/ipv4/ip_output.c | 13 +-
>> kernel/drivers/net/stack/ipv4/ip_sock.c | 73 +-
>> kernel/drivers/net/stack/ipv4/protocol.c | 17 +
>> kernel/drivers/net/stack/ipv4/route.c | 56 +-
>> kernel/drivers/net/stack/ipv4/tcp/tcp.c | 2 +-
>> kernel/drivers/net/stack/ipv4/udp/udp.c | 53 +-
>> kernel/drivers/net/stack/rtdev.c | 214 +
>> kernel/drivers/net/stack/rtnet_chrdev.c | 8 +-
>> kernel/drivers/net/stack/rtnet_module.c | 5 +
>> kernel/drivers/net/stack/socket.c | 17 +-
>> kernel/drivers/net/stack/stack_mgr.c | 2 +-
>> kernel/drivers/net/stack/vlan.c | 725 +++
>> utils/net/Makefile.am | 1 +
>> utils/net/rtifconfig.c | 2 +-
>> utils/net/rtping.c | 16 +-
>> utils/net/rtroute.c | 39 +-
>> utils/net/rtvconfig.c | 257 +
>> 69 files changed, 10741 insertions(+), 2142 deletions(-)
>> create mode 100644 demo/net/Makefile.am
>> create mode 100644 demo/net/mcast-receiver.c
>> create mode 100644 demo/net/mcast-sender.c
>> create mode 100644 demo/net/raw-ethernet.c
>> create mode 100644 demo/net/rtt-mcast-measure.c
>> create mode 100644 demo/net/rtt-mcast-responder.c
>> create mode 100644 demo/net/rtt-responder.c
>> create mode 100644 demo/net/rtt-sender.c
>> create mode 100644 demo/net/rttcp-client.c
>> create mode 100644 demo/net/rttcp-server.c
>> create mode 100644 demo/net/udp-send.c
>> delete mode 100644 kernel/drivers/net/drivers/fec.c
>> create mode 100644 kernel/drivers/net/drivers/freescale/Makefile
>> create mode 100644 kernel/drivers/net/drivers/freescale/fec.h
>> create mode 100644 kernel/drivers/net/drivers/freescale/fec_main.c
>> create mode 100644 kernel/drivers/net/drivers/freescale/fec_ptp.c
>> delete mode 100644 kernel/drivers/net/drivers/rt_fec.h
>> create mode 100644 kernel/drivers/net/stack/include/ipv4/igmp.h
>> create mode 100644 kernel/drivers/net/stack/include/rtif_vlan.h
>> create mode 100644 kernel/drivers/net/stack/include/rtvlan.h
>> create mode 100644 kernel/drivers/net/stack/ipv4/igmp.c
>> create mode 100644 kernel/drivers/net/stack/vlan.c
>> create mode 100644 utils/net/rtvconfig.c
>>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-06-12 17:00 ` Jean-Baptiste Trédez
@ 2021-06-13 17:13 ` Jan Kiszka
2021-06-14 6:55 ` Philippe Gerum
0 siblings, 1 reply; 40+ messages in thread
From: Jan Kiszka @ 2021-06-13 17:13 UTC (permalink / raw)
To: Jean-Baptiste Trédez, xenomai, Philippe Gerum
On 12.06.21 19:00, Jean-Baptiste Trédez wrote:
> Le 04/06/2021 à 11:14, Jan Kiszka a écrit :
>> On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
>>> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8
>>> support
>>>
>>> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with
>>> updated driver for 4.18.85 kernel
>> May I assume that submission of this branch has been coordinated between
>> you two, and Philippe considers them ready as well? Some patches lack
>> descriptions, and maybe I will find more things that should be adjusted
>> first. Will you address them then, Jean-Baptiste?
>>
>> Jan
>
> I rebased the work on fec driver with the rtnet-mcast+vlan branch on
> next, as suggested by Philippe, and added separated patch (patch 30 and
> 31) to show what i would like to change on previous work and added patch
> 28 and 29 to upgrade to 5.4.x kernels.
>
> I will address your findings on the fec driver and test it with a 5.4
> kernel on our target. I am not very familiar with the multicast and vlan
> work, if the work is not ready, i can submit the fec driver without the
> mcast+vlan work.
>
Then it's better to split that, also the make the series smaller and,
thus, easier to digest for me.
Thanks,
Jan
--
Siemens AG, T RDA IOT
Corporate Competence Center Embedded Linux
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-06-13 17:13 ` Jan Kiszka
@ 2021-06-14 6:55 ` Philippe Gerum
2021-06-14 7:41 ` Jan Kiszka
0 siblings, 1 reply; 40+ messages in thread
From: Philippe Gerum @ 2021-06-14 6:55 UTC (permalink / raw)
To: Jan Kiszka; +Cc: Jean-Baptiste Trédez, xenomai
Jan Kiszka <jan.kiszka@siemens.com> writes:
> On 12.06.21 19:00, Jean-Baptiste Trédez wrote:
>> Le 04/06/2021 à 11:14, Jan Kiszka a écrit :
>>> On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
>>>> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8
>>>> support
>>>>
>>>> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with
>>>> updated driver for 4.18.85 kernel
>>> May I assume that submission of this branch has been coordinated between
>>> you two, and Philippe considers them ready as well? Some patches lack
>>> descriptions, and maybe I will find more things that should be adjusted
>>> first. Will you address them then, Jean-Baptiste?
>>>
>>> Jan
>>
>> I rebased the work on fec driver with the rtnet-mcast+vlan branch on
>> next, as suggested by Philippe, and added separated patch (patch 30 and
>> 31) to show what i would like to change on previous work and added patch
>> 28 and 29 to upgrade to 5.4.x kernels.
>>
>> I will address your findings on the fec driver and test it with a 5.4
>> kernel on our target. I am not very familiar with the multicast and vlan
>> work, if the work is not ready, i can submit the fec driver without the
>> mcast+vlan work.
>>
>
> Then it's better to split that, also the make the series smaller and,
> thus, easier to digest for me.
>
A bit of context to clarify:
I submitted the multicast and vlan series for inclusion in 3.x two years
ago [1], but it could not make it into the 3.1 series due to bad timing
(release date too close) and lack of time for the review process
basically. Since then, it has been in use in lab configuration at
iXblue, so far so good.
This series is a port to Xenomai 3.1 of a work Gilles did on top of
2.6.5 back in 2015. This original work is production software since
then.
[1] https://xenomai.org/pipermail/xenomai/2019-March/040588.html
--
Philippe.
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH 00/31] Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8 support
2021-06-14 6:55 ` Philippe Gerum
@ 2021-06-14 7:41 ` Jan Kiszka
0 siblings, 0 replies; 40+ messages in thread
From: Jan Kiszka @ 2021-06-14 7:41 UTC (permalink / raw)
To: Philippe Gerum; +Cc: Jean-Baptiste Trédez, xenomai
On 14.06.21 08:55, Philippe Gerum wrote:
>
> Jan Kiszka <jan.kiszka@siemens.com> writes:
>
>> On 12.06.21 19:00, Jean-Baptiste Trédez wrote:
>>> Le 04/06/2021 à 11:14, Jan Kiszka a écrit :
>>>> On 11.05.21 18:05, Jean-Baptiste Trédez via Xenomai wrote:
>>>>> Update fec driver for xenomai 3 and linux kernel 5.4 and add I.MX8
>>>>> support
>>>>>
>>>>> Patch 1 to 27 : rtnet-mcast+vlan branch from Philippe Gerum with
>>>>> updated driver for 4.18.85 kernel
>>>> May I assume that submission of this branch has been coordinated between
>>>> you two, and Philippe considers them ready as well? Some patches lack
>>>> descriptions, and maybe I will find more things that should be adjusted
>>>> first. Will you address them then, Jean-Baptiste?
>>>>
>>>> Jan
>>>
>>> I rebased the work on fec driver with the rtnet-mcast+vlan branch on
>>> next, as suggested by Philippe, and added separated patch (patch 30 and
>>> 31) to show what i would like to change on previous work and added patch
>>> 28 and 29 to upgrade to 5.4.x kernels.
>>>
>>> I will address your findings on the fec driver and test it with a 5.4
>>> kernel on our target. I am not very familiar with the multicast and vlan
>>> work, if the work is not ready, i can submit the fec driver without the
>>> mcast+vlan work.
>>>
>>
>> Then it's better to split that, also the make the series smaller and,
>> thus, easier to digest for me.
>>
>
> A bit of context to clarify:
>
> I submitted the multicast and vlan series for inclusion in 3.x two years
> ago [1], but it could not make it into the 3.1 series due to bad timing
> (release date too close) and lack of time for the review process
> basically. Since then, it has been in use in lab configuration at
> iXblue, so far so good.
>
> This series is a port to Xenomai 3.1 of a work Gilles did on top of
> 2.6.5 back in 2015. This original work is production software since
> then.
>
> [1] https://xenomai.org/pipermail/xenomai/2019-March/040588.html
>
We still have time for 3.2 inclusion, and I'm not against merging it. It
"just" takes someone to drive that, including the address possible
(though likely not fundamental) change requests.
Jan
--
Siemens AG, T RDA IOT
Corporate Competence Center Embedded Linux
^ permalink raw reply [flat|nested] 40+ messages in thread