0 获取源码

git clone https://gitlab.com/etherlab.org/ethercat.git
git checkout stable-1.6

1 启动脚本

root@vbox:/home/ethercat# tree ./script/
./script/
├── ethercat.bash_completion
├── ethercat.conf
├── ethercatctl.in
├── ethercat.service.in
├── ifup-eoe.sh
├── init.d
│   ├── ethercat.in
│   └── Makefile.am
├── Makefile.am
└── sysconfig
    ├── ethercat
    └── Makefile.am

2 directories, 10 files

#
# EtherCAT master kernel modules
#

[Unit]
Description=EtherCAT Master Kernel Modules

# Fine tuning of the startup dependencies below are recommended
# to provide a reliable startup routine.
# The dependencies below can be either uncommented after copying
# this file to /etc/systemd/system or by creating overrides:
# Copy the needed dependencies into
# /etc/systemd/system/ethercat.service.d/50-dependencies.conf
# in a [Unit] section.

#
# Uncomment this, if the generic Ethernet driver is used. It assures, that the
# network interfaces are configured, before the master starts.
#
#Requires=network.target # Stop master, if network is stopped
#After=network.target # Start master, after network is ready

#
# Uncomment this, if a native Ethernet driver is used. It assures, that the
# network interfaces are configured, after the Ethernet drivers have been
# replaced. Otherwise, the networking configuration tools could be confused.
#
#Before=network-pre.target
#Wants=network-pre.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=@sbindir@/ethercatctl start
ExecStop=@sbindir@/ethercatctl stop

[Install]
WantedBy=multi-user.target

#!/bin/bash

#------------------------------------------------------------------------------
#
#  Start script for EtherCAT to use with systemd
#
#  Copyright (C) 2006-2021  Florian Pose, Ingenieurgemeinschaft IgH
#
#  This file is part of the IgH EtherCAT Master.
#
#  The IgH EtherCAT Master 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.
#
#  The IgH EtherCAT Master 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 the IgH EtherCAT Master; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#
#  vim: expandtab sw=4 tw=78
#
#------------------------------------------------------------------------------

LSMOD=/sbin/lsmod
MODPROBE=/sbin/modprobe
RMMOD=/sbin/rmmod
MODINFO=/sbin/modinfo
IP=/bin/ip

ETHERCAT=@bindir@/ethercat

#------------------------------------------------------------------------------

ETHERCAT_CONFIG=@sysconfdir@/ethercat.conf

if [ ! -r ${ETHERCAT_CONFIG} ]; then
    echo ${ETHERCAT_CONFIG} not existing;
    exit 6
fi

# shellcheck source=/etc/ethercat.conf
. ${ETHERCAT_CONFIG}

#------------------------------------------------------------------------------

parse_mac_address() {
    local DEVICENAMETOMAC
    if [ -z "${1}" ]; then
        MAC=""
    elif echo ${1} | grep -qE '^([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$'; then
        MAC=${1}
    else
        DEVICENAMETOMAC=$("${IP}" address show dev "${1}" |
            awk '/link\/ether/ { print $2; }')
        if echo "${DEVICENAMETOMAC}" |
            grep -qE '^([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$'; then
            MAC=${DEVICENAMETOMAC}
        else
            echo Invalid MAC address or interface name \""${1}"\" \
                in ${ETHERCAT_CONFIG}
            exit 1
        fi
    fi
}

#------------------------------------------------------------------------------

case "${1}" in

start)
    # construct DEVICES and BACKUPS from configuration variables
    DEVICES=""
    BACKUPS=""
    MASTER_INDEX=0

    while true; do
        DEVICE=$(eval echo "\${MASTER${MASTER_INDEX}_DEVICE}")
        BACKUP=$(eval echo "\${MASTER${MASTER_INDEX}_BACKUP}")
        if [ -z "${DEVICE}" ]; then break; fi

        if [ ${MASTER_INDEX} -gt 0 ]; then
            DEVICES=${DEVICES},
            BACKUPS=${BACKUPS},
        fi

        parse_mac_address "${DEVICE}"
        DEVICES=${DEVICES}${MAC}

        parse_mac_address "${BACKUP}"
        BACKUPS=${BACKUPS}${MAC}

        MASTER_INDEX=$((${MASTER_INDEX} + 1))
    done

    if [ -z "${DEVICES}" ]; then
        echo "ERROR: No network cards for EtherCAT specified."
        echo -n "Please edit ${ETHERCAT_CONFIG} with root permissions"
        echo -n " and set MASTER0_DEVICE variable to either a "
        echo "network interface name (like eth0) or to a MAC address."
        exit 1
    fi

    # load master module
    if ! ${MODPROBE} ${MODPROBE_FLAGS} ec_master \
            main_devices="${DEVICES}" backup_devices="${BACKUPS}"; then
        exit 1
    fi

    LOADED_MODULES=ec_master

    # check for modules to replace
    for MODULE in ${DEVICE_MODULES}; do
        ECMODULE=ec_${MODULE}
        if ! ${MODINFO} "${ECMODULE}" > /dev/null; then
            continue # ec_* module not found
        fi

        if [ "${MODULE}" != "generic" ] && [ "${MODULE}" != "ccat" ]; then
            # unload standard module and check if unloading was successful
            ${RMMOD} "${MODULE}" 2> /dev/null || true
            if ${LSMOD} | grep "^${MODULE} " > /dev/null; then
                # could not unload module
                ${RMMOD} ${LOADED_MODULES}
                exit 1
            fi
        fi

        if ! ${MODPROBE} ${MODPROBE_FLAGS} "${ECMODULE}"; then
            if [ "${MODULE}" != "generic" ] && [ "${MODULE}" != "ccat" ]; then
                ${MODPROBE} ${MODPROBE_FLAGS} "${MODULE}" # try to restore
            fi
            ${RMMOD} ${LOADED_MODULES}
            exit 1
        fi

        LOADED_MODULES="${ECMODULE} ${LOADED_MODULES}"
    done

    exit 0
    ;;

#------------------------------------------------------------------------------

stop)
    # unload EtherCAT device modules
    for MODULE in ${DEVICE_MODULES} master; do
        ECMODULE=ec_${MODULE}
        if ! ${LSMOD} | grep -q "^${ECMODULE} "; then
            continue # ec_* module not loaded
        fi
        if ! ${RMMOD} "${ECMODULE}"; then
            exit 1
        fi;
    done

    sleep 1

    # load standard modules again
    for MODULE in ${DEVICE_MODULES}; do
        if [ "${MODULE}" == "generic" ] || [ "${MODULE}" == "ccat" ]; then
            continue
        fi
        ${MODPROBE} ${MODPROBE_FLAGS} "${MODULE}"
    done

    exit 0
    ;;

#------------------------------------------------------------------------------

restart)
    $0 stop || exit 1
    sleep 1
    $0 start
    ;;

#------------------------------------------------------------------------------

status)
    echo "Checking for EtherCAT master @VERSION@ "

    # count masters in configuration file
    MASTER_COUNT=0
    while true; do
        DEVICE=$(eval echo "\${MASTER${MASTER_COUNT}_DEVICE}")
        if [ -z "${DEVICE}" ]; then break; fi
        MASTER_COUNT=$((${MASTER_COUNT} + 1))
    done

    RESULT=0

    for i in $(seq 0 "$((${MASTER_COUNT} - 1))"); do
        echo -n "Master${i} "

        # Check if the master is in idle or operation phase
        ${ETHERCAT} master --master "${i}" 2>/dev/null | \
            grep -qE 'Phase:[[:space:]]*Idle|Phase:[[:space:]]*Operation'
        EXITCODE=$?

        if [ ${EXITCODE} -eq 0 ]; then
            echo " running"
        else
            echo " dead"
            RESULT=1
        fi
    done

    exit ${RESULT}
    ;;

#------------------------------------------------------------------------------

*)
    echo "USAGE: $0 {start|stop|restart|status}"
    exit 1
    ;;
esac

#------------------------------------------------------------------------------

#!/bin/sh

#------------------------------------------------------------------------------
#
#  Init script for EtherCAT
#
#  Copyright (C) 2006-2021  Florian Pose, Ingenieurgemeinschaft IgH
#
#  This file is part of the IgH EtherCAT Master.
#
#  The IgH EtherCAT Master 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.
#
#  The IgH EtherCAT Master 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 the IgH EtherCAT Master; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#
#
#  vim: expandtab
#
#------------------------------------------------------------------------------

### BEGIN INIT INFO
# Provides:          ethercat
# Required-Start:    $local_fs $syslog $network
# Should-Start:      $time ntp
# Required-Stop:     $local_fs $syslog $network
# Should-Stop:       $time ntp
# Default-Start:     3 5
# Default-Stop:      0 1 2 6
# Short-Description: EtherCAT master
# Description:       EtherCAT master @VERSION@
### END INIT INFO

#------------------------------------------------------------------------------

LSMOD=/sbin/lsmod
MODPROBE=/sbin/modprobe
RMMOD=/sbin/rmmod
MODINFO=/sbin/modinfo
ETHERCAT=@prefix@/bin/ethercat
MASTER_ARGS=

#------------------------------------------------------------------------------

ETHERCAT_CONFIG=/etc/sysconfig/ethercat

if [ ! -r ${ETHERCAT_CONFIG} ]; then
    echo ${ETHERCAT_CONFIG} not existing;
    if [ "${1}" = "stop" ]; then
        exit 0
    else
        exit 6
    fi
fi

. ${ETHERCAT_CONFIG}

#------------------------------------------------------------------------------

exit_success() {
    if [ -r /etc/rc.status ]; then
        rc_reset
        rc_status -v
        rc_exit
    else
        echo " done"
        exit 0
    fi
}

#------------------------------------------------------------------------------

exit_fail() {
    if [ -r /etc/rc.status ]; then
        rc_failed
        rc_status -v
        rc_exit
    else
        echo " failed"
        exit 1
    fi
}

#------------------------------------------------------------------------------

print_running() {
    if [ -r /etc/rc.status ]; then
        rc_reset
        rc_status -v
    else
        echo " running"
    fi
}

#------------------------------------------------------------------------------

print_dead() {
    if [ -r /etc/rc.status ]; then
        rc_failed
        rc_status -v
    else
        echo " dead"
    fi
}

#------------------------------------------------------------------------------

parse_mac_address() {
    if [ -z "${1}" ]; then
        MAC=""
    elif echo "${1}" | grep -qE '^([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$'; then
        MAC=${1}
    else
        echo Invalid MAC address \""${1}"\" in ${ETHERCAT_CONFIG}
        exit_fail
    fi
}

#------------------------------------------------------------------------------

if [ -r /etc/rc.status ]; then
    . /etc/rc.status
    rc_reset
fi

case "${1}" in

start)
    echo -n "Starting EtherCAT master @VERSION@ "

    # construct DEVICES and BACKUPS from configuration variables
    DEVICES=""
    BACKUPS=""
    MASTER_INDEX=0
    while true; do
        DEVICE=$(eval echo "\${MASTER${MASTER_INDEX}_DEVICE}")
        BACKUP=$(eval echo "\${MASTER${MASTER_INDEX}_BACKUP}")
        if [ -z "${DEVICE}" ]; then break; fi

        if [ ${MASTER_INDEX} -gt 0 ]; then
            DEVICES=${DEVICES},
            BACKUPS=${BACKUPS},
        fi

        parse_mac_address "${DEVICE}"
        DEVICES=${DEVICES}${MAC}

        parse_mac_address "${BACKUP}"
        BACKUPS=${BACKUPS}${MAC}

        MASTER_INDEX=$((${MASTER_INDEX} + 1))
    done

    # load master module
    if ! ${MODPROBE} ${MODPROBE_FLAGS} ec_master "${MASTER_ARGS}" \
            main_devices="${DEVICES}" backup_devices="${BACKUPS}"; then
        exit_fail
    fi

    # check for modules to replace
    for MODULE in ${DEVICE_MODULES}; do
        ECMODULE=ec_${MODULE}
        if ! ${MODINFO} "${ECMODULE}" > /dev/null; then
            continue # ec_* module not found
        fi
        if [ "${MODULE}" != "generic" ]; then
            if ${LSMOD} | grep "^${MODULE} " > /dev/null; then
                if ! ${RMMOD} "${MODULE}"; then
                    exit_fail
                fi
            fi
        fi
        if ! ${MODPROBE} ${MODPROBE_FLAGS} "${ECMODULE}"; then
            if [ "${MODULE}" != "generic" ]; then
                ${MODPROBE} ${MODPROBE_FLAGS} "${MODULE}" # try to restore
            fi
            exit_fail
        fi
    done

    exit_success
    ;;

stop)
    echo -n "Shutting down EtherCAT master @VERSION@ "

    # unload EtherCAT device modules
    for MODULE in ${DEVICE_MODULES} master; do
        ECMODULE=ec_${MODULE}
        if ! ${LSMOD} | grep -q "^${ECMODULE} "; then
            continue # ec_* module not loaded
        fi
        if ! ${RMMOD} "${ECMODULE}"; then
            exit_fail
        fi;
    done

    sleep 1

    # reload previous modules
    for MODULE in ${DEVICE_MODULES}; do
        if [ "${MODULE}" != "generic" ]; then
            if ! ${MODPROBE} ${MODPROBE_FLAGS} "${MODULE}"; then
                echo Warning: Failed to restore "${MODULE}".
            fi
        fi
    done

    exit_success
    ;;

restart)
    $0 stop || exit 1
    sleep 1
    $0 start
    ;;

status)
    echo "Checking for EtherCAT master @VERSION@ "

    # count masters in configuration file
    MASTER_COUNT=0
    while true; do
        DEVICE=$(eval echo "\${MASTER${MASTER_COUNT}_DEVICE}")
        if [ -z "${DEVICE}" ]; then break; fi
        MASTER_COUNT=$((${MASTER_COUNT} + 1))
    done

    RESULT=0

    for i in $(seq 0 "$((${MASTER_COUNT} - 1))"); do
        echo -n "Master${i} "

        # Check if the master is in idle or operation phase
        ${ETHERCAT} master --master "${i}" 2>/dev/null | \
            grep -qE 'Phase:[[:space:]]*Idle|Phase:[[:space:]]*Operation'
        EXITCODE=$?

        if [ ${EXITCODE} -eq 0 ]; then
            print_running
        else
            print_dead
            RESULT=1
        fi
    done

    exit ${RESULT}
    ;;

*)
    echo "USAGE: $0 {start|stop|restart|status}"
    ;;

esac

if [ -r /etc/rc.status ]; then
    rc_exit
else
    exit 1
fi

#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
#
#  EtherCAT master configuration file for use with ethercatctl.
#
#  vim: spelllang=en spell tw=78
#
#------------------------------------------------------------------------------

#
# Main Ethernet devices.
#
# The MASTER<X>_DEVICE variable specifies the Ethernet device for a master
# with index 'X'.
#
# Specify the MAC address (hexadecimal with colons) of the Ethernet device to
# use. Example: "00:00:08:44:ab:66"
#
# Alternatively, a network interface name can be specified. The interface
# name will be resolved to a MAC address using the 'ip' command.
# Example: "eth0"
#
# The broadcast address "ff:ff:ff:ff:ff:ff" has a special meaning: It tells
# the master to accept the first device offered by any Ethernet driver.
#
# The MASTER<X>_DEVICE variables also determine, how many masters will be
# created: A non-empty variable MASTER0_DEVICE will create one master, adding a
# non-empty variable MASTER1_DEVICE will create a second master, and so on.
#
# Examples:
# MASTER0_DEVICE="00:00:08:44:ab:66"
# MASTER0_DEVICE="eth0"
#
MASTER0_DEVICE=""
#MASTER1_DEVICE=""

#
# Backup Ethernet devices
#
# The MASTER<X>_BACKUP variables specify the devices used for redundancy. They
# behaves nearly the same as the MASTER<X>_DEVICE variable, except that it
# does not interpret the ff:ff:ff:ff:ff:ff address.
#
#MASTER0_BACKUP=""

#
# Ethernet driver modules to use for EtherCAT operation.
#
# Specify a non-empty list of Ethernet drivers, that shall be used for
# EtherCAT operation.
#
# Except for the generic Ethernet driver module, the init script will try to
# unload the usual Ethernet driver modules in the list and replace them with
# the EtherCAT-capable ones. If a certain (EtherCAT-capable) driver is not
# found, a warning will appear.
#
# Possible values: 8139too, e100, e1000, e1000e, r8169, generic, ccat, igb, igc, genet, dwmac-intel, stmmac-pci.
# Separate multiple drivers with spaces.
# A list of all matching kernel versions can be found here:
# https://docs.etherlab.org/ethercat/1.6/doxygen/devicedrivers.html
#
# Note: The e100, e1000, e1000e, r8169, ccat, igb and igc drivers are not built by
# default. Enable them with the --enable-<driver> configure switches.
#
# Attention: When using the generic driver, the corresponding Ethernet device
# has to be activated (with OS methods, for example 'ip link set ethX up'),
# before the master is started, otherwise all frames will time out.
#
DEVICE_MODULES=""

# If you have any issues about network interfaces not being configured
# properly, systemd may need some additional infos about your setup.
# Have a look at the service file, you'll find some details there.
#

#
# Flags for loading kernel modules.
#
# This can usually be left empty. Adjust this variable, if you have problems
# with module loading.
#
#MODPROBE_FLAGS="-b"

#------------------------------------------------------------------------------

1.1 start

1. 加载 ec_master.ko 模块
模块参数包括：
• main_devices：主网卡的MAC地址，多个 main_devices 表示创建多个主站，MAC参数个数由 master_count 决定。
• backup_devices：备用网卡的MAC地址，多个 backup_devices 表示创建多个备用主站，MAC参数个数由 backup_count 决定。
• debug_level：调试级别，控制调试信息输出级别。
• eoe_interfaces：EOE接口，eoe_count 表示 eoe_interfaces 的个数。
• eoe_autocreate：是否自动创建EOE handler。
• pcap_size：Pcap缓冲区大小。

2. 读取 /etc/sysconfig/ethercat 中的环境变量 DEVICE_MODULES，该变量位于 ethercat.conf 中。

3. 在每个 DEVICE_MODULES 前添加前缀 ec_，例如，如果 DEVICE_MODULES 为 igb，则添加前缀后为 ec_igb。

4. 使用 modinfo 检查该模块是否存在。

5. 对于非generic和rtdm的驱动，需要先将网卡与当前驱动unbind，unbind后的网卡才能被新驱动接管。

6. 对于 generic 和 rtdm 驱动，需要先将网卡与当前驱动解绑（unbind），解绑后的网卡才能被新驱动接管。

7. 加载该驱动。

1.2 stop

1. 遍历配置文件中的环境变量 DEVICE_MODULES。

2. 在每个 DEVICE_MODULES 前添加前缀 ec_。

3. 使用 lsmod 检查该模块是否已加载。

4. 卸载模块。

在后文中，“主站”和“master”均表示主站或主站实例对象，“slave”和“从站”表示从站或从站对象，中英混用，不做刻意区分。

2 主站实例创建

if (master_count) {
        if (alloc_chrdev_region(&device_number,
                    0, master_count, "EtherCAT")) {
            EC_ERR("Failed to obtain device number(s)!\n");
...
        }
    }

 class = class_create(THIS_MODULE, "EtherCAT");

 for (i = 0; i < master_count; i++) {
        ret = ec_mac_parse(macs[i][0], main_devices[i], 0);

        if (i < backup_count) {
            ret = ec_mac_parse(macs[i][1], backup_devices[i], 1);
        }
    }

    if (master_count) {
        if (!(masters = kmalloc(sizeof(ec_master_t) * master_count,
                        GFP_KERNEL))) {
            ...
        }
    }

    for (i = 0; i < master_count; i++) {
        ret = ec_master_init(&masters[i], i, macs[i][0], macs[i][1],
                    device_number, class, debug_level);
       ...
    }

2.1 Master Phases

• Orphaned phase：此时主站实例已分配并初始化，正在等待以太网设备连接，即尚未与网卡驱动关联，此时无法进行总线通信。

• Idle phase：当主站与网卡绑定后，Idle线程 ec_master_idle_thread 开始运行，主站处于IDLE状态。ec_master_idle_thread 主要完成从站拓扑扫描、配置站点地址等工作。该阶段命令行工具能够访问总线，但无法进行过程数据交换，因为总线配置尚未完成。

• Operation phase：应用程序请求主站提供总线配置并激活主站后，主站进入Operation状态。ec_master_idle_thread 停止运行，内核线程变为 ec_master_operation_thread，之后应用程序可以周期性地交换过程数据。

2.2 数据报

2.2.1 EtherCAT 数据报格式

2.2.2 ec_datagram_t 结构体

typedef struct {
    struct list_head queue; /**< Master datagram queue item, 用于将数据报插入主站的发送队列中。
					    通过用户提供的互斥锁（mutex）进行保护，确保多线程环境下的线程安全。 */
    struct list_head ext_queue; /**< 用于将数据报插入外部队列中。
					    保护机制：通过信号量 ext_queue_sem 进行保护，确保外部队列的线程安全。 */
    struct list_head sent; /**< 用于将已发送的数据报插入主站的已发送列表中。
							主站通过该列表跟踪已发送但尚未收到响应的数据报。 */
    ec_device_index_t device_index; /**< 表示数据报将通过哪个网络设备（网卡）发送或接收。
					    主站可能支持多个网卡设备，device_index 用于指定具体的设备。 */
    ec_datagram_type_t type; /**< 表示数据报的类型。
					    常见类型：
						  APRD：自动增量读取。
						  BWR：广播写。 */
    uint8_t address[EC_ADDR_LEN]; /**< 表示数据报的目标地址（从站地址）。
					    EC_ADDR_LEN 是地址的长度，通常为 4 字节。*/
    uint8_t *data; /**< 指向数据报的有效载荷（payload），有效载荷是实际传输的数据内容，大小由 data_size 决定。 */
    ec_origin_t data_origin; /**< 表示数据报有效载荷的内存来源。可能的值包括：
																	EC_ORIG_INTERNAL：数据来自主站内部。
																	EC_ORIG_EXTERNAL：数据来自外部（如用户空间）。 */
    size_t mem_size; /**< 表示数据报有效载荷的内存大小。
					    这是实际分配的内存大小，可能大于 data_size。 */
    size_t data_size; /**< 表示数据报有效载荷中实际使用的数据大小。
					    data_size 必须小于或等于 mem_size。 */
    uint8_t index; /**< Index (set by master). */
    uint16_t working_counter; /**< 表示数据报的工作计数器（Working Counter, WKC）
					    WKC 是 EtherCAT 协议中的一个重要字段，用于确认从站是否正确处理了数据报。 */
    ec_datagram_state_t state; /**< 表示数据报的当前状态。
					    常见状态：
									EC_DATAGRAM_INIT：数据报已初始化。
									EC_DATAGRAM_QUEUED：数据报已插入发送队列。
									EC_DATAGRAM_SENT：数据报已发送。
									EC_DATAGRAM_RECEIVED：数据报已接收。
									EC_DATAGRAM_TIMED_OUT：数据报超时。
									EC_DATAGRAM_ERROR：数据报发送或接收过程中出错。 */
#ifdef EC_HAVE_CYCLES
    cycles_t cycles_sent; /**< 记录数据报发送的时间。
					    使用高精度计时器（cycles）记录的时间。 */
#endif
    unsigned long jiffies_sent; /**< 记录数据报发送的时间。
					    使用内核的 jiffies 记录的时间。 */
#ifdef EC_HAVE_CYCLES
    cycles_t cycles_received; /**< 记录数据报接收的时间。
					    使用高精度计时器（cycles）记录的时间。 */
#endif
    unsigned long jiffies_received; /**< 记录数据报接收的时间。
					    使用内核的 jiffies 记录的时间。 */
    unsigned int skip_count; /**< 记录数据报未被接收时的重试次数。
					    当数据报未被接收时，主站会重新将其加入队列，skip_count 记录重试次数。 */
    unsigned long stats_output_jiffies; /**< 记录最后一次统计输出的时间。
					    用于性能统计和调试。 */
    char name[EC_DATAGRAM_NAME_SIZE]; /**< 数据报的描述信息。
					    用于调试和日志记录，便于识别数据报的用途。 */
} ec_datagram_t;

1. device_index
• 作用：表示该数据报是通过哪个网卡设备发送或接收的。
• 背景：在 IgH 中，一个 master 实例可以绑定多个网卡设备（例如主网卡和备用网卡），用于发送和接收 EtherCAT 数据帧。device_index 用于标识当前数据报所属的网卡设备。
• 示例：如果 master 绑定了两个网卡，device_index 可以区分数据报是通过主网卡还是备用网卡发送的。

2. data_origin
• 作用：表示该数据报的内存来源类别。
• 背景：在 IgH 中，master 管理着多个空闲的 ec_datagram_t 对象，这些对象根据用途被分为不同的类别（例如内部使用、外部使用等）。data_origin 用于标识当前数据报属于哪一类别。
• 后续说明：具体的分类和用途将在后文详细讨论。

3. index
• 作用：表示该数据报在 EtherCAT 数据区中的子报文索引。
• 背景：一个完整的 EtherCAT 数据帧可能包含多个子报文，每个子报文都有一个唯一的索引。index 用于标识当前数据报是第几个子报文。
• 使用场景：在 master 组装以太网数据帧时，会根据 index 将多个子报文按顺序组合成一个完整的数据帧。

4. data
• 作用：指向子报文的数据内存区。
• 背景：每个子报文的数据内容可能不同，因此数据区是动态分配的。data 指针指向实际的数据内存区域。
• 相关字段：mem_size 表示分配的内存大小，而 data_size 表示实际使用的数据大小。

5. mem_size
• 作用：表示数据报数据区的分配内存大小。
• 说明：由于每个子报文的数据大小可能不同，mem_size 记录了为数据区分配的总内存大小，以确保有足够的空间存储数据。

6. data_size
• 作用：表示数据报中实际使用的数据大小。
• 示例：如果该数据报用于读取从站的某个寄存器，data_size 就是该寄存器的大小。
• 与 mem_size 的关系：data_size 必须小于或等于 mem_size。

7. jiffies_sent、jiffies_received、cycles_sent、cycles_received
• 作用：记录数据报的发送和接收时间，用于统计和调试。
• 背景：
• jiffies_sent 和 jiffies_received 使用内核的 jiffies 计时方式，记录数据报的发送和接收时间。
• cycles_sent 和 cycles_received 使用高精度计时器（cycles），提供更精确的时间记录。
• 使用场景：这些时间戳用于分析数据报的传输延迟、网络性能等。

• EC_DATAGRAM_INIT ：数据报已经初始化

• EC_DATAGRAM_QUEUED ：数据报已插入发送队列

• EC_DATAGRAM_SENT ：数据报已经发送(还存在队列中）

• EC_DATAGRAM_RECEIVED：该数据报已接收，并从发送队列删除

• EC_DATAGRAM_TIMED_OUT ：该数据报发送后，接收超时，从发送队列删除

• EC_DATAGRAM_ERROR : 发送和接收过程中出错(从队列删除)，校验错误、不匹配等。

2.2.3 M 位的作用

• 发送时：在主站组装 EtherCAT 数据帧时，M 位（More 位）用于指示当前子报文是否是最后一个子报文。如果 M 位为 1，表示后面还有更多的子报文；如果 M 位为 0，表示当前子报文是最后一个。

• 接收时：从站根据 M 位判断是否还有后续子报文需要处理。如果 M 位为 1，从站会继续处理下一个子报文；如果 M 位为 0，从站会停止处理并返回响应。

/** Constructor.
 */
void ec_datagram_init(ec_datagram_t *datagram /**< EtherCAT datagram. */)
{
		// 初始化链表头，标记该数据报尚未加入任何队列
    INIT_LIST_HEAD(&datagram->queue); // mark as unqueued
    datagram->device_index = EC_DEVICE_MAIN;         /* 默认主设备使用 */
    datagram->type = EC_DATAGRAM_NONE;               /* EtherCAT datagram type. */
    memset(datagram->address, 0x00, EC_ADDR_LEN);    /* 数据报地址清零 */
    datagram->data = NULL;                           /* 数据指针初始化为空 */
    datagram->data_origin = EC_ORIG_INTERNAL;        /* 设置数据来源为内部 */
    datagram->mem_size = 0;                          /* 内存大小初始化为0 */
    datagram->data_size = 0;                         /* 数据大小初始化为0 */
    datagram->index = 0x00;                          /* 索引初始化为0 */
    datagram->working_counter = 0x0000;              /* 工作计数器初始化为0 */
    datagram->state = EC_DATAGRAM_INIT;              /* 状态设置为初始化状态 */
#ifdef EC_HAVE_CYCLES
    datagram->cycles_sent = 0;
#endif
    datagram->jiffies_sent = 0;
#ifdef EC_HAVE_CYCLES
    datagram->cycles_received = 0;
#endif
    datagram->jiffies_received = 0;
    datagram->skip_count = 0;
    datagram->stats_output_jiffies = 0;
    memset(datagram->name, 0x00, EC_DATAGRAM_NAME_SIZE); /* 将数据报名称字段清零 */
}

2.3 状态机

2.3.1 有限状态机（FSM）概述

1. 状态机在某个状态（如 A0）中填充数据报（datagram）。

2. 数据报通过 EtherCAT 数据帧发送到从站，经过从站的 ESC（EtherCAT Slave Controller）处理。

3. 处理后的数据报返回到主站的网卡接收端。

4. 主站将接收到的数据报交给状态机的下一个状态（如 A1）进行解析和处理。

2.3.2 IgH 中状态机的基本表示

struct ec_fsm_change
{
    ec_slave_t *slave; /**< slave the FSM runs on */
    ec_datagram_t *datagram; /**< datagram used in the state machine */
    unsigned int retries; /**< retries upon datagram timeout */

    void (*state)(ec_fsm_change_t *); /**< slave state change state function */
    ec_fsm_change_mode_t mode; /**< full state change, or ack only. */
    ec_slave_state_t requested_state; /**< input: state */
    ec_slave_state_t old_state; /**< prior slave state */
    unsigned long jiffies_start; /**< change timer */
    uint8_t take_time; /**< take sending timestamp */
    uint8_t spontaneous_change; /**< spontaneous state change detected */
};

struct ec_fsm_xxx {
    ec_datagram_t *datagram; /**< 主站状态机使用的数据报对象 */
    void (*state)(ec_fsm_master_t *); /**< 状态函数 */
    ....
};

• datagram：指向状态机操作的数据报对象。每个状态机都需要操作一个数据报对象，用于与从站进行数据交换。

• state：状态函数指针，指向当前状态的处理函数。状态函数负责执行当前状态的操作，并决定状态机的下一步转移。

2.3.3 master状态机

• Bus monitoring 监控EtherCAT总线拓扑结构，如果发生改变，则重新扫描。

• Slave con fguration 监视从站的应用程序层状态。如果从站未处于其应有的状态，则从站将被（重新）配置

• Request handling 请求处理（源自应用程序或外部来源），主站任务应该处理异步请求，例如:SII访问，SDO访问或类似。

/** Finite state machine of an EtherCAT master.
 */
struct ec_fsm_master {
    ec_master_t *master; /**< 指向当前状态机所属的主站实例。
						    每个主站状态机都与一个特定的主站实例关联，通过该指针可以访问主站的其他属性和方法。 */
    ec_datagram_t *datagram; /**< 指向状态机使用的数据报对象。
						    状态机通过数据报与从站进行通信，datagram 是状态机操作的核心对象。 */
    unsigned int retries; /**< 记录数据报超时时的重试次数。
						    当数据报发送后未收到响应时，状态机会根据 retries 决定是否重试。 */

    void (*state)(ec_fsm_master_t *); /**< 指向当前状态的处理函数。
						    状态机通过该函数指针执行当前状态的操作，并根据操作结果决定状态转移。 */
    ec_device_index_t dev_idx; /**< 表示当前状态机使用的网卡设备索引。
                主站可能绑定多个网卡设备，dev_idx 用于标识当前操作使用的设备。 */
    int idle; /**< 表示状态机是否处于空闲阶段（Idle Phase）。
						    在空闲阶段，主站会执行从站扫描和配置等操作。 */
    unsigned long scan_jiffies; /**< 记录从站扫描开始的时间（以 jiffies 为单位）。
						    用于计算从站扫描的耗时。 */
    uint8_t link_state[EC_MAX_NUM_DEVICES]; /**< 记录每个网卡设备的链路状态。
						    EC_MAX_NUM_DEVICES 是主站支持的最大网卡设备数量，为1。 */
    unsigned int slaves_responding[EC_MAX_NUM_DEVICES]; /**< 记录每个网卡设备响应的从站数量。
						    用于监控总线上从站的响应情况。 */
    unsigned int rescan_required; /**< 表示是否需要重新扫描总线。
						    当总线拓扑发生变化时，该标志会被设置。 */
    ec_slave_state_t slave_states[EC_MAX_NUM_DEVICES]; /**< 记录每个网卡设备上从站的应用层（AL）状态。
						    用于监控从站的状态是否符合预期。 */
    ec_slave_t *slave; /**< 指向当前正在处理的从站对象。
						    在从站扫描或配置过程中，状态机会操作特定的从站对象。 */
    ec_sii_write_request_t *sii_request; /**< 指向 SII（Slave Information Interface）写请求对象。
						    用于处理从站的 SII 写操作。 */
    off_t sii_index; /**< 表示 SII 写请求数据的索引。
						    用于定位 SII 写请求的数据位置。 */
    ec_sdo_request_t *sdo_request; /**< 指向 SDO（Service Data Object）请求对象。
						    用于处理从站的 SDO 读写操作。 */
    ec_soe_request_t *soe_request; /**< 指向 SoE（Servo Drive over EtherCAT）请求对象。
						    用于处理从站的 SoE 操作。 */

    ec_fsm_coe_t fsm_coe; /**< 表示 CoE（CANopen over EtherCAT）状态机。
						    用于处理 CoE 协议相关的状态转换。 */
    ec_fsm_soe_t fsm_soe; /**< 表示 SoE 状态机。
						    用于处理 SoE 协议相关的状态转换。 */
    ec_fsm_pdo_t fsm_pdo; /**< 表示 PDO（Process Data Object）配置状态机。
						    用于处理 PDO 的配置和映射。 */
    ec_fsm_eoe_t fsm_eoe; /**< 表示 EoE（Ethernet over EtherCAT）状态机。
						    用于处理 EoE 协议相关的状态转换。 */
    ec_fsm_change_t fsm_change; /**< 表示状态变更状态机。
						    用于处理从站状态的变更。 */
    ec_fsm_slave_config_t fsm_slave_config; /**< 表示从站配置状态机。
						    用于处理从站的配置过程。 */
    ec_fsm_slave_scan_t fsm_slave_scan; /**< 表示从站扫描状态机。
						    用于处理从站的扫描过程。 */
    ec_fsm_sii_t fsm_sii; /**< 表示 SII 状态机。
						    用于处理从站的 SII 读写操作。 */
};

2.3.4 slave 状态机

struct ec_slave
{
    ec_master_t *master; /**< Master owning the slave. */
.....
    ec_fsm_slave_t fsm; /**< Slave state machine. */
.....
};
struct ec_fsm_slave {
    ec_slave_t *slave; /**< slave the FSM runs on */
    struct list_head list; /**< Used for execution list. */
    ec_dict_request_t int_dict_request; /**< Internal dictionary request. */

    void (*state)(ec_fsm_slave_t *, ec_datagram_t *); /**< State function. */
    ec_datagram_t *datagram; /**< Previous state datagram. */
    ec_sdo_request_t *sdo_request; /**< SDO request to process. */
    ec_reg_request_t *reg_request; /**< Register request to process. */
    ec_foe_request_t *foe_request; /**< FoE request to process. */
    off_t foe_index; /**< Index to FoE write request data. */
    ec_soe_request_t *soe_request; /**< SoE request to process. */
    ec_eoe_request_t *eoe_request; /**< EoE request to process. */
    ec_mbg_request_t *mbg_request; /**< MBox Gateway request to process. */
    ec_dict_request_t *dict_request; /**< Dictionary request to process. */

    ec_fsm_coe_t fsm_coe; /**< CoE state machine. */
    ec_fsm_foe_t fsm_foe; /**< FoE state machine. */
    ec_fsm_soe_t fsm_soe; /**< SoE state machine. */
    ec_fsm_eoe_t fsm_eoe; /**< EoE state machine. */
    ec_fsm_mbg_t fsm_mbg; /**< MBox Gateway state machine. */
    ec_fsm_pdo_t fsm_pdo; /**< PDO configuration state machine. */
    ec_fsm_change_t fsm_change; /**< State change state machine */
    ec_fsm_slave_scan_t fsm_slave_scan; /**< slave scan state machine */
    ec_fsm_slave_config_t fsm_slave_config; /**< slave config state machine. */
};

• 主站管理从站状态

• 主站与从站应用层(AL)通讯。比如具有EoE功能的从站,主站通过该从站下的子状态机fsm_eoe来管理主站与从站应用层的EOE通讯。

2.3.5 数据报对象的管理

struct ec_master {
    ...
    ec_datagram_t fsm_datagram; /**< Datagram used for state machines. */
    ...
    ec_datagram_t ref_sync_datagram; /**< Datagram used for synchronizing the
                                       reference clock to the master clock.*/
    ec_datagram_t sync_datagram; /**< Datagram used for DC drift
                                   compensation. */
    ec_datagram_t sync_mon_datagram; /**< Datagram used for DC synchronisation
                                       monitoring. */
    ...
    ec_datagram_t ext_datagram_ring[EC_EXT_RING_SIZE]; /* 32 */
}

int ec_datagram_prealloc(
        ec_datagram_t *datagram, /**< EtherCAT datagram. */
        size_t size /**< New payload size in bytes. */
        )
{
    if (datagram->data_origin == EC_ORIG_EXTERNAL
            || size <= datagram->mem_size)
        return 0;
	......

    if (!(datagram->data = kmalloc(size, GFP_KERNEL))) {
	......
    }

    datagram->mem_size = size;
    return 0;
}

/** Size of an EtherCAT frame header. */
#define EC_FRAME_HEADER_SIZE 2

/** Size of an EtherCAT datagram header. */
#define EC_DATAGRAM_HEADER_SIZE 10

/** Size of an EtherCAT datagram footer. */
#define EC_DATAGRAM_FOOTER_SIZE 2

/** Size of the EtherCAT address field. */
#define EC_ADDR_LEN 4

/** Resulting maximum data size of a single datagram in a frame. */
#define EC_MAX_DATA_SIZE (ETH_DATA_LEN - EC_FRAME_HEADER_SIZE \
                          - EC_DATAGRAM_HEADER_SIZE - EC_DATAGRAM_FOOTER_SIZE)

2.4 master状态机及数据报初始化

2.4.1 模块入口函数 ec_init_module(void)

/** Module initialization.
 *
 * Initializes \a master_count masters.
 * \return 0 on success, else < 0
 */
int __init ec_init_module(void)
{
    int i, ret = 0;

    EC_INFO("Master driver %s\n", EC_MASTER_VERSION);

    sema_init(&master_sem, 1);

    if (master_count) {
        if (alloc_chrdev_region(&device_number,
                    0, master_count, "EtherCAT")) {
            EC_ERR("Failed to obtain device number(s)!\n");
            ret = -EBUSY;
            goto out_return;
        }
    }

#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 4, 0)
    class = class_create(THIS_MODULE, "EtherCAT");
#else
    class = class_create("EtherCAT");
#endif
    if (IS_ERR(class)) {
        EC_ERR("Failed to create device class.\n");
        ret = PTR_ERR(class);
        goto out_cdev;
    }

    // zero MAC addresses
    memset(macs, 0x00, sizeof(uint8_t) * EC_MAX_MASTERS * 2 * ETH_ALEN);

    // process MAC parameters
    for (i = 0; i < master_count; i++) {
        ret = ec_mac_parse(macs[i][0], main_devices[i], 0);
        if (ret)
            goto out_class;

        if (i < backup_count) {
            ret = ec_mac_parse(macs[i][1], backup_devices[i], 1);
            if (ret)
                goto out_class;
        }
    }

    // initialize static master variables
    ec_master_init_static();

    if (master_count) {
        if (!(masters = kmalloc(sizeof(ec_master_t) * master_count,
                        GFP_KERNEL))) {
            EC_ERR("Failed to allocate memory"
                    " for EtherCAT masters.\n");
            ret = -ENOMEM;
            goto out_class;
        }
    }

    for (i = 0; i < master_count; i++) {
        ret = ec_master_init(&masters[i], i, macs[i][0], macs[i][1],
                    device_number, class, debug_level, run_on_cpu);
        if (ret)
            goto out_free_masters;
    }

    EC_INFO("%u master%s waiting for devices.\n",
            master_count, (master_count == 1 ? "" : "s"));
    return ret;

out_free_masters:
    for (i--; i >= 0; i--)
        ec_master_clear(&masters[i]);
    kfree(masters);
out_class:
    class_destroy(class);
out_cdev:
    if (master_count)
        unregister_chrdev_region(device_number, master_count);
out_return:
    return ret;
}

1. 初始化全局信号量。

2. 分配字符设备号。

3. 创建设备类。

4. 解析主站和备用网卡的 MAC 地址。

5. 初始化主站的静态变量。

6. 分配并初始化主站实例。

7. 处理错误情况并释放资源。

2.4.2 ec_master_init_static(void)

/** Static variables initializer.
*/
void ec_master_init_static(void)
{
#ifdef EC_HAVE_CYCLES
    timeout_cycles = (cycles_t) EC_IO_TIMEOUT /* us */ * (cpu_khz / 1000);
    ext_injection_timeout_cycles =
        (cycles_t) EC_SDO_INJECTION_TIMEOUT /* us */ * (cpu_khz / 1000);
#else
    // one jiffy may always elapse between time measurement
    timeout_jiffies = max(EC_IO_TIMEOUT * HZ / 1000000, 1);
    ext_injection_timeout_jiffies =
        max(EC_SDO_INJECTION_TIMEOUT * HZ / 1000000, 1);
#endif
}

1. 根据是否支持高精度计时器（EC_HAVE_CYCLES），计算超时时间。

2. 设置 I/O 操作超时时间和外部注入超时时间。

• 说明：
• jiffies 是 Linux 内核中的一种时间单位，表示系统启动以来的时钟滴答数。
• timeout_jiffies 是 I/O 操作的超时时间，单位为 jiffies。
• ext_injection_timeout_jiffies 是外部注入（如 SDO 操作）的超时时间，单位为 jiffies。
• HZ 是内核的时钟频率（每秒的时钟滴答数）。
• 公式：超时时间（jiffies） = 超时时间（us） * HZ / 1000000。
• max() 函数确保超时时间至少为 1 个 jiffy，避免超时时间为 0。

• 如果支持高精度计时器，使用 CPU 周期数（cycles）作为超时时间的单位。

• 如果不支持高精度计时器，使用 jiffies 作为超时时间的单位。

2.4.3 ec_master_init()

1. master初始化：使用sema_init()和ec_master_clear_device_stats()函数来初始化master及其相关的信号量和统计信息。

2. MAC地址分配：通过检查EC_MAX_NUM_DEVICES是否大于1，将main_mac和backup_mac分别赋值给master->macs[EC_DEVICE_MAIN]和master->macs[EC_DEVICE_BACKUP]。

3. 初始化设备：通过调用ec_device_init()函数来初始化master的所有设备，如果其中任何一个失败，代码会执行goto out_clear_devices跳转到清理部分。

4. 状态机和数据报文初始化：使用ec_datagram_init()和ec_fsm_master_init()函数来初始化FSM和数据报文。

5. 外部数据报文环的初始化：创建一个EC_EXT_RING_SIZE大小的数组，并使用ec_datagram_prealloc()函数为每个元素分配内存空间。

6. 同步和引用同步数据报文的初始化：通过调用ec_datagram_init()和ec_datagram_prealloc()函数来初始化这些数据报文，并预分配它们所需的大小。

7. 字符设备初始化：使用ec_cdev_init()函数创建一个新的字符设备用于与用户空间通信。

8. RTDM设备的初始化（如果定义了EC_RTDM）：尝试通过调用ec_rtdm_dev_init()函数来初始化RTDM设备，如果失败会跳转到out_unregister_class_device标签。

9. 清理部分（在任何一个步骤中初始化失败时执行）：如果初始化过程中的某一步失败，代码将使用一系列的ec_datagram_clear()、ec_fsm_master_clear()和ec_device_clear()调用来清除所有已经分配的资源。

static unsigned int run_on_cpu = 0xffffffff; /**< Bind created kernel threads
                                               to a cpu. Default do not bind.
                                              */
int __init ec_init_module(void)
{
........
    for (i = 0; i < master_count; i++) {
        ret = ec_master_init(&masters[i], i, macs[i][0], macs[i][1],
                    device_number, class, debug_level, run_on_cpu);
        if (ret)
            goto out_free_masters;
    }
.......
}
/**
   Master constructor.
   \return 0 in case of success, else < 0
*/
int ec_master_init(ec_master_t *master, /**< EtherCAT master */
        unsigned int index, /**< master index */
        const uint8_t *main_mac, /**< MAC address of main device */
        const uint8_t *backup_mac, /**< MAC address of backup device */
        dev_t device_number, /**< Character device number. */
        struct class *class, /**< Device class. */
        unsigned int debug_level, /**< Debug level (module parameter). */
        unsigned int run_on_cpu /**< bind created kernel threads to a cpu */
        )
{
    int ret;
    unsigned int dev_idx, i;

    master->index = index;
    master->reserved = 0;

    sema_init(&master->master_sem, 1);

		// 每个主设备只有一个网卡设备，EC_MAX_NUM_DEVICES 为 1
    for (dev_idx = EC_DEVICE_MAIN; dev_idx < EC_MAX_NUM_DEVICES; dev_idx++) {
        master->macs[dev_idx] = NULL;
    }

    master->macs[EC_DEVICE_MAIN] = main_mac;

#if EC_MAX_NUM_DEVICES > 1
    master->macs[EC_DEVICE_BACKUP] = backup_mac;
    master->num_devices = 1 + !ec_mac_is_zero(backup_mac);
#else
    if (!ec_mac_is_zero(backup_mac)) {
        EC_MASTER_WARN(master, "Ignoring backup MAC address!");
    }
#endif
/**
index 是主站的索引，用于标识不同的主站实例。
master_sem 是主站的信号量，用于保护对主站资源的并发访问。
macs 数组存储主站的主网卡和备用网卡的 MAC 地址。
如果支持备用网卡（EC_MAX_NUM_DEVICES > 1），则初始化备用网卡的 MAC 地址；否则忽略备用网卡的 MAC 地址。
*/
    ec_master_clear_device_stats(master);

    sema_init(&master->device_sem, 1);

    master->phase = EC_ORPHANED;
    master->active = 0;
    master->config_changed = 0;
    master->injection_seq_fsm = 0;
    master->injection_seq_rt = 0;

    master->slaves = NULL;
    master->slave_count = 0;

    INIT_LIST_HEAD(&master->configs);
    INIT_LIST_HEAD(&master->domains);

    master->app_time = 0ULL;
    master->dc_ref_time = 0ULL;

    master->scan_busy = 0;
    master->scan_index = 0;
    master->allow_scan = 1;
    sema_init(&master->scan_sem, 1);
    init_waitqueue_head(&master->scan_queue);

    master->config_busy = 0;
    sema_init(&master->config_sem, 1);
    init_waitqueue_head(&master->config_queue);

    INIT_LIST_HEAD(&master->datagram_queue);
    master->datagram_index = 0;

    INIT_LIST_HEAD(&master->ext_datagram_queue);
    sema_init(&master->ext_queue_sem, 1);

    master->ext_ring_idx_rt = 0;
    master->ext_ring_idx_fsm = 0;
/**
作用：初始化主站的信号量、队列和链表。
说明：
device_sem 是设备操作的信号量。
phase 表示主站的当前阶段（如 EC_ORPHANED）。
slaves 和 slave_count 用于管理从站。
configs 和 domains 是配置和域的链表。
scan_sem 和 config_sem 是扫描和配置操作的信号量。
datagram_queue 和 ext_datagram_queue 是数据报的队列。
*/
    // init external datagram ring
    for (i = 0; i < EC_EXT_RING_SIZE; i++) {
        ec_datagram_t *datagram = &master->ext_datagram_ring[i];
        ec_datagram_init(datagram);
        snprintf(datagram->name, EC_DATAGRAM_NAME_SIZE, "ext-%u", i);
    }
/**
作用：初始化外部数据报环形缓冲区。
说明：
ext_datagram_ring 是一个环形缓冲区，用于存储外部数据报。
每个数据报通过 ec_datagram_init() 初始化，并设置名称。
*/
    // send interval in IDLE phase
    ec_master_set_send_interval(master, 1000000 / HZ);
/**
作用：设置 IDLE 阶段的发送间隔。
说明：
send_interval 是数据报的发送间隔，单位为微秒。
HZ 是内核的时钟频率（每秒的时钟滴答数）。
*/
    master->fsm_slave = NULL;
    INIT_LIST_HEAD(&master->fsm_exec_list);
    master->fsm_exec_count = 0U;

    master->debug_level = debug_level;
    master->run_on_cpu = run_on_cpu;
    master->stats.timeouts = 0;
    master->stats.corrupted = 0;
    master->stats.unmatched = 0;
    master->stats.output_jiffies = 0;

    master->thread = NULL;

#ifdef EC_EOE
    master->eoe_thread = NULL;
    INIT_LIST_HEAD(&master->eoe_handlers);
#endif

    rt_mutex_init(&master->io_mutex);
    master->send_cb = NULL;
    master->receive_cb = NULL;
    master->cb_data = NULL;
    master->app_send_cb = NULL;
    master->app_receive_cb = NULL;
    master->app_cb_data = NULL;

    INIT_LIST_HEAD(&master->sii_requests);
    INIT_LIST_HEAD(&master->emerg_reg_requests);

    init_waitqueue_head(&master->request_queue);

    // init devices
    for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
            dev_idx++) {
        ret = ec_device_init(&master->devices[dev_idx], master);
        if (ret < 0) {
            goto out_clear_devices;
        }
    }

    // init state machine datagram
    ec_datagram_init(&master->fsm_datagram);
    snprintf(master->fsm_datagram.name, EC_DATAGRAM_NAME_SIZE, "master-fsm");
    ret = ec_datagram_prealloc(&master->fsm_datagram, EC_MAX_DATA_SIZE);
    if (ret < 0) {
        ec_datagram_clear(&master->fsm_datagram);
        EC_MASTER_ERR(master, "Failed to allocate FSM datagram.\n");
        goto out_clear_devices;
    }
/**
作用：初始化主站状态机和数据报。
说明：
fsm_datagram 是主站状态机使用的数据报。
ec_fsm_master_init() 初始化主站状态机，并指定使用的数据报。
*/
    // create state machine object
    ec_fsm_master_init(&master->fsm, master, &master->fsm_datagram);

    // alloc external datagram ring
    for (i = 0; i < EC_EXT_RING_SIZE; i++) {
        ec_datagram_t *datagram = &master->ext_datagram_ring[i];
        ret = ec_datagram_prealloc(datagram, EC_MAX_DATA_SIZE);
        if (ret) {
            EC_MASTER_ERR(master, "Failed to allocate external"
                    " datagram %u.\n", i);
            goto out_clear_ext_datagrams;
        }
    }

    // init reference sync datagram
    ec_datagram_init(&master->ref_sync_datagram);
    snprintf(master->ref_sync_datagram.name, EC_DATAGRAM_NAME_SIZE,
            "refsync");
    ret = ec_datagram_prealloc(&master->ref_sync_datagram, 4);
    if (ret < 0) {
        ec_datagram_clear(&master->ref_sync_datagram);
        EC_MASTER_ERR(master, "Failed to allocate reference"
                " synchronisation datagram.\n");
        goto out_clear_ext_datagrams;
    }

    // init sync datagram
    ec_datagram_init(&master->sync_datagram);
    snprintf(master->sync_datagram.name, EC_DATAGRAM_NAME_SIZE, "sync");
    ret = ec_datagram_prealloc(&master->sync_datagram, 4);
    if (ret < 0) {
        ec_datagram_clear(&master->sync_datagram);
        EC_MASTER_ERR(master, "Failed to allocate"
                " synchronisation datagram.\n");
        goto out_clear_ref_sync;
    }

    // init sync monitor datagram
    ec_datagram_init(&master->sync_mon_datagram);
    snprintf(master->sync_mon_datagram.name, EC_DATAGRAM_NAME_SIZE,
            "syncmon");
    ret = ec_datagram_brd(&master->sync_mon_datagram, 0x092c, 4);
    if (ret < 0) {
        ec_datagram_clear(&master->sync_mon_datagram);
        EC_MASTER_ERR(master, "Failed to allocate sync"
                " monitoring datagram.\n");
        goto out_clear_sync;
    }

    master->dc_ref_config = NULL;
    master->dc_ref_clock = NULL;

    INIT_WORK(&master->sc_reset_work, sc_reset_task);
    init_irq_work(&master->sc_reset_work_kicker, sc_reset_task_kicker);

    // init character device
    ret = ec_cdev_init(&master->cdev, master, device_number);
    if (ret)
        goto out_clear_sync_mon;

    master->class_device = device_create(class, NULL,
            MKDEV(MAJOR(device_number), master->index), NULL,
            "EtherCAT%u", master->index);
    if (IS_ERR(master->class_device)) {
        EC_MASTER_ERR(master, "Failed to create class device!\n");
        ret = PTR_ERR(master->class_device);
        goto out_clear_cdev;
    }

#ifdef EC_RTDM
    // init RTDM device
    ret = ec_rtdm_dev_init(&master->rtdm_dev, master);
    if (ret) {
        goto out_unregister_class_device;
    }
#endif
/**
作用：初始化字符设备和 RTDM 设备。
说明：
ec_cdev_init() 初始化字符设备。
device_create() 创建设备节点。
如果启用 RTDM（实时设备模型），则初始化 RTDM 设备。
*/

    return 0;

#ifdef EC_RTDM
out_unregister_class_device:
    device_unregister(master->class_device);
#endif
out_clear_cdev:
    ec_cdev_clear(&master->cdev);
out_clear_sync_mon:
    ec_datagram_clear(&master->sync_mon_datagram);
out_clear_sync:
    ec_datagram_clear(&master->sync_datagram);
out_clear_ref_sync:
    ec_datagram_clear(&master->ref_sync_datagram);
out_clear_ext_datagrams:
    for (i = 0; i < EC_EXT_RING_SIZE; i++) {
        ec_datagram_clear(&master->ext_datagram_ring[i]);
    }
    ec_fsm_master_clear(&master->fsm);
    ec_datagram_clear(&master->fsm_datagram);
out_clear_devices:
    for (; dev_idx > 0; dev_idx--) {
        ec_device_clear(&master->devices[dev_idx - 1]);
    }
    return ret;
}

    // init state machine datagram
    ec_datagram_init(&master->fsm_datagram); /*初始化数据报对象*/
    snprintf(master->fsm_datagram.name, EC_DATAGRAM_NAME_SIZE, "master-fsm");
    ret = ec_datagram_prealloc(&master->fsm_datagram, EC_MAX_DATA_SIZE);

    // create state machine object
    ec_fsm_master_init(&master->fsm, master, &master->fsm_datagram); /*初始化master fsm*/

void ec_fsm_master_init(
        ec_fsm_master_t *fsm, /**< Master state machine. */
        ec_master_t *master, /**< EtherCAT master. */
        ec_datagram_t *datagram /**< Datagram object to use. */
        )
{
    fsm->master = master;
    fsm->datagram = datagram;
    // inits the member variables state, idle, dev_idx, link_state,
    // slaves_responding, slave_states and rescan_required
    ec_fsm_master_reset(fsm);

    // init sub-state-machines
    ec_fsm_coe_init(&fsm->fsm_coe);
    ec_fsm_soe_init(&fsm->fsm_soe);
    ec_fsm_pdo_init(&fsm->fsm_pdo, &fsm->fsm_coe);
    ec_fsm_change_init(&fsm->fsm_change, fsm->datagram);
    ec_fsm_slave_config_init(&fsm->fsm_slave_config, fsm->datagram,
            &fsm->fsm_change, &fsm->fsm_coe, &fsm->fsm_soe, &fsm->fsm_pdo,
            &fsm->fsm_eoe);
    ec_fsm_slave_scan_init(&fsm->fsm_slave_scan, fsm->datagram,
            &fsm->fsm_slave_config, &fsm->fsm_pdo);
    ec_fsm_sii_init(&fsm->fsm_sii, fsm->datagram);
}

2.4.4 初始化外部数据报队列

    // alloc external datagram ring
    for (i = 0; i < EC_EXT_RING_SIZE; i++) {
        ec_datagram_t *datagram = &master->ext_datagram_ring[i];
        ret = ec_datagram_prealloc(datagram, EC_MAX_DATA_SIZE);
        if (ret) {
            EC_MASTER_ERR(master, "Failed to allocate external"
                    " datagram %u.\n", i);
            goto out_clear_ext_datagrams;
        }
    }

INIT_LIST_HEAD(&master->ext_datagram_queue);

    ec_datagram_init(&master->sync_mon_datagram);
	......
    ret = ec_datagram_brd(&master->sync_mon_datagram, 0x092c, 4);

    for (dev_idx = EC_DEVICE_MAIN; dev_idx < EC_MAX_NUM_DEVICES; dev_idx++) {
        master->macs[dev_idx] = NULL;
    }

    master->macs[EC_DEVICE_MAIN] = main_mac;

2.5 初始化EtherCAT device

struct ec_device
{
    ec_master_t *master; /**< EtherCAT master */
    struct net_device *dev; /**< 使用的网络设备 */
    ec_pollfunc_t poll; /**< pointer to the device's poll function */
    struct module *module; /**< pointer to the device's owning module */
    uint8_t open; /**< true, if the net_device has been opened */
    uint8_t link_state; /**< device link state */
    struct sk_buff *tx_skb[EC_TX_RING_SIZE]; /**< transmit skb ring */
    unsigned int tx_ring_index; /**< last ring entry used to transmit */
#ifdef EC_HAVE_CYCLES
    cycles_t cycles_poll; /**< cycles of last poll */
#endif
#ifdef EC_DEBUG_RING
    struct timeval timeval_poll;
#endif
    unsigned long jiffies_poll; /**< jiffies of last poll */

    // Frame statistics
    u64 tx_count; /**< 发送的帧数 */
    u64 last_tx_count; /**<上次统计周期发送的帧数。 */
    u64 rx_count; /**< 接收的帧数 */
    u64 last_rx_count; /**< 上一个统计周期收到的帧数。 */

    u64 tx_bytes; /**< 发送的字节数 */
    u64 last_tx_bytes; /**< 上一个统计周期发送的字节数。 */
    u64 rx_bytes; /**< Number of bytes received. */
    u64 last_rx_bytes; /**< Number of bytes received of last statistics cycle.
                        */
    u64 tx_errors; /**< Number of transmit errors. */
    s32 tx_frame_rates[EC_RATE_COUNT]; /**< Transmit rates in frames/s for
                                         different statistics cycle periods.
                                        */
    s32 rx_frame_rates[EC_RATE_COUNT]; /**< Receive rates in frames/s for
                                         different statistics cycle periods.
                                        */
    s32 tx_byte_rates[EC_RATE_COUNT]; /**< Transmit rates in byte/s for
                                        different statistics cycle periods. */
    s32 rx_byte_rates[EC_RATE_COUNT]; /**< Receive rates in byte/s for
                                        different statistics cycle periods. */

......
};

/*\master\master.c*/
    for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
            dev_idx++) {
        ret = ec_device_init(&master->devices[dev_idx], master);
        if (ret < 0) {
            goto out_clear_devices;
        }
    }
/*\master\device.c*/
int ec_device_init(
        ec_device_t *device, /**< EtherCAT device */
        ec_master_t *master /**< master owning the device */
        )
{
    int ret;
    unsigned int i;
    struct ethhdr *eth;
....

    device->master = master;
    device->dev = NULL;
    device->poll = NULL;
    device->module = NULL;
    device->open = 0;
    device->link_state = 0;
    for (i = 0; i < EC_TX_RING_SIZE; i++) {
        device->tx_skb[i] = NULL;
    }
......

    ec_device_clear_stats(device);
......
    for (i = 0; i < EC_TX_RING_SIZE; i++) {
        if (!(device->tx_skb[i] = dev_alloc_skb(ETH_FRAME_LEN))) {
            ......
        }

        // add Ethernet-II-header
        skb_reserve(device->tx_skb[i], ETH_HLEN);
        eth = (struct ethhdr *) skb_push(device->tx_skb[i], ETH_HLEN);
        eth->h_proto = htons(0x88A4);
        memset(eth->h_dest, 0xFF, ETH_ALEN);
    }
.....
}

2.6 设置IDLE 线程的发送间隔:

ec_master_set_send_interval(master, 1000000 / HZ);

void ec_master_set_send_interval(
        ec_master_t *master, /**< EtherCAT master */
        unsigned int send_interval /**< Send interval */
        )
{
    master->send_interval = send_interval;  //发送间隔 us
    master->max_queue_size =
        (send_interval * 1000) / EC_BYTE_TRANSMISSION_TIME_NS;
    master->max_queue_size -= master->max_queue_size / 10;
}

2.7 初始化字符设备

	......
	master->class_device = device_create(class, NULL,
            MKDEV(MAJOR(device_number), master->index), NULL,
            "EtherCAT%u", master->index);
    ......
#ifdef EC_RTDM
    // init RTDM device
    ret = ec_rtdm_dev_init(&master->rtdm_dev, master);
   ...
#endif

关于网卡驱动代码详细解析推荐这两篇文章：

Monitoring and Tuning the Linux Networking Stack: Sending Data

Monitoring and Tuning the Linux Networking Stack: Receiving Data

3 网卡

1. 网卡probe

static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
    ......
	adapter->ecdev = ecdev_offer(netdev, ec_poll, THIS_MODULE);
	if (adapter->ecdev) {	/*注册打开ec_net设备*/
		err = ecdev_open(adapter->ecdev);
		.....
		adapter->ec_watchdog_jiffies = jiffies;
	} else { /*注册普通网络设备*/
		......
		err = register_netdev(netdev);
		......
	}
    ......
}

2. 给主站提供网络设备：ecdev_offer ，根据MAC地址找到master下的ec_device_t对象

    device->dev = net_dev;
    device->poll = poll;
    device->module = module;

上面我们只设置了ec_device_t->tx_skb[]中sk_buff的以太网类型和目的地址，现在继续填充源MAC地址为网卡的MAC地址、sk_buff所属的net_device：

    for (i = 0; i < EC_TX_RING_SIZE; i++) {
        device->tx_skb[i]->dev = net_dev;
        eth = (struct ethhdr *) (device->tx_skb[i]->data);
        memcpy(eth->h_source, net_dev->dev_addr, ETH_ALEN);
    }

3. 调用网络设备接口打开网络设备

int ec_device_open(
        ec_device_t *device /**< EtherCAT device */
        )
{
    int ret;
.....
    ret = device->dev->open(device->dev);
    if (!ret)
        device->open = 1;
....
    return ret;
}

4. 当master下的所有的网络设备都open后，master从ORPHANED转到IDLE阶段

int ec_master_enter_idle_phase(
        ec_master_t *master /**< EtherCAT master */
        )
{
    int ret;
    ec_device_index_t dev_idx;
	......
    master->send_cb = ec_master_internal_send_cb;
    master->receive_cb = ec_master_internal_receive_cb;
    master->cb_data = master;

    master->phase = EC_IDLE;  /*更新master状态*/

    // reset number of responding slaves to trigger scanning
    for (dev_idx = EC_DEVICE_MAIN; dev_idx < ec_master_num_devices(master);
            dev_idx++) {
        master->fsm.slaves_responding[dev_idx] = 0;
    }

    ret = ec_master_nrthread_start(master, ec_master_idle_thread,
            "EtherCAT-IDLE");
    ....
    return ret;
}

4 IDLE阶段内核线程

static int ec_master_idle_thread(void *priv_data)
{
    ec_master_t *master = (ec_master_t *) priv_data;
    int fsm_exec;
#ifdef EC_USE_HRTIMER
    size_t sent_bytes;
#endif

    // send interval in IDLE phase
    ec_master_set_send_interval(master, 250000 / HZ);

    while (!kthread_should_stop()) {
        // receive
        ecrt_master_receive(master);  /*接收上个循环发送的数据帧*/
		......
        // execute master & slave state machines
        ......
        fsm_exec = ec_fsm_master_exec(&master->fsm); /*执行master状态机*/

        ec_master_exec_slave_fsms(master); /*为从站状态机分配datagram，并执行从站状态机*/
		......
        if (fsm_exec) {
            ec_master_queue_datagram(master, &master->fsm_datagram); /*将master状态机处理的datagram插入发送链表*/
        }
        // send
        ecrt_master_send(master); /*组装以太网帧并调用网卡发送*/

        sent_bytes = master->devices[EC_DEVICE_MAIN].tx_skb[
            master->devices[EC_DEVICE_MAIN].tx_ring_index]->len;
        up(&master->io_sem);

        if (ec_fsm_master_idle(&master->fsm)) {
            ec_master_nanosleep(master->send_interval * 1000);
            set_current_state(TASK_INTERRUPTIBLE);
            schedule_timeout(1);
        } else {
            ec_master_nanosleep(sent_bytes * EC_BYTE_TRANSMISSION_TIME_NS);
        }
    }

    EC_MASTER_DBG(master, 1, "Master IDLE thread exiting...\n");

    return 0;
}

4.1 数据报发送

4.2 数据报接收

1. 得到子报文index，遍历发送链表datagram_queue，找到index对应的datagram。

2. 将子报文数据拷贝到datagram数据区。

3. 将以太网帧内子报文中的WKC值复制到datagram中的WKC。

4. 将datagram从链表datagram_queue删除。

5. 根据子报文头M位判断还有没有子报文，有则跳转1继续处理下一个子报文，否则完成接收。