slave.c

Go to the documentation of this file.

/*****************************************************************************
 *
 *  Copyright (C) 2006-2026  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
 *
 ****************************************************************************/

/****************************************************************************/

#include <linux/module.h>
#include <linux/delay.h>

#include "globals.h"
#include "datagram.h"
#include "master.h"
#include "slave_config.h"

#include "slave.h"

/****************************************************************************/

extern const ec_code_msg_t al_status_messages[];

/****************************************************************************/

// prototypes for private methods
char *ec_slave_sii_string(const ec_slave_t *, unsigned int);
void ec_slave_find_names_for_pdo(ec_slave_t *, ec_pdo_t *);
unsigned int ec_slave_get_previous_port(const ec_slave_t *, unsigned int);
unsigned int ec_slave_get_next_port(const ec_slave_t *, unsigned int);
uint32_t ec_slave_calc_rtt_sum(const ec_slave_t *);
ec_slave_t *ec_slave_find_next_dc_slave(ec_slave_t *);
int ec_slave_fetch_sii_strings(ec_slave_t *, const uint8_t *, size_t);
int ec_slave_fetch_sii_general(ec_slave_t *, const uint8_t *, size_t);
int ec_slave_fetch_sii_syncs(ec_slave_t *, const uint8_t *, size_t);
int ec_slave_fetch_sii_pdos(ec_slave_t *, const uint8_t *, size_t,
        ec_direction_t);

/****************************************************************************/

void ec_slave_init(
        ec_slave_t *slave, 
        ec_master_t *master, 
        ec_device_index_t dev_idx, 
        uint16_t ring_position, 
        uint16_t station_address 
        )
{
    unsigned int i;

    slave->master = master;
    slave->device_index = dev_idx;
    slave->ring_position = ring_position;
    slave->station_address = station_address;
    slave->effective_alias = 0x0000;

    slave->config = NULL;
    slave->requested_state = EC_SLAVE_STATE_PREOP;
    slave->current_state = EC_SLAVE_STATE_UNKNOWN;
    slave->error_flag = 0;
    slave->force_config = 0;
    slave->configured_rx_mailbox_offset = 0x0000;
    slave->configured_rx_mailbox_size = 0x0000;
    slave->configured_tx_mailbox_offset = 0x0000;
    slave->configured_tx_mailbox_size = 0x0000;

    slave->base_type = 0;
    slave->base_revision = 0;
    slave->base_build = 0;
    slave->base_fmmu_count = 0;
    slave->base_sync_count = 0;

    for (i = 0; i < EC_MAX_PORTS; i++) {
        slave->ports[i].desc = EC_PORT_NOT_IMPLEMENTED;

        slave->ports[i].link.link_up = 0;
        slave->ports[i].link.loop_closed = 0;
        slave->ports[i].link.signal_detected = 0;
        slave->sii.physical_layer[i] = 0xFF;

        slave->ports[i].receive_time = 0U;

        slave->ports[i].next_slave = NULL;
        slave->ports[i].delay_to_next_dc = 0U;
    }

    slave->base_fmmu_bit_operation = 0;
    slave->base_dc_supported = 0;
    slave->base_dc_range = EC_DC_32;
    slave->has_dc_system_time = 0;
    slave->transmission_delay = 0U;

    ec_sii_page_init(&slave->sii_page);
    slave->sii_parallel_words = 0;

    slave->sii.alias = 0x0000;
    slave->sii.vendor_id = 0x00000000;
    slave->sii.product_code = 0x00000000;
    slave->sii.revision_number = 0x00000000;
    slave->sii.serial_number = 0x00000000;
    slave->sii.boot_rx_mailbox_offset = 0x0000;
    slave->sii.boot_rx_mailbox_size = 0x0000;
    slave->sii.boot_tx_mailbox_offset = 0x0000;
    slave->sii.boot_tx_mailbox_size = 0x0000;
    slave->sii.std_rx_mailbox_offset = 0x0000;
    slave->sii.std_rx_mailbox_size = 0x0000;
    slave->sii.std_tx_mailbox_offset = 0x0000;
    slave->sii.std_tx_mailbox_size = 0x0000;
    slave->sii.mailbox_protocols = 0;

    slave->sii.strings = NULL;
    slave->sii.string_count = 0;

    slave->sii.has_general = 0;
    slave->sii.group = NULL;
    slave->sii.image = NULL;
    slave->sii.order = NULL;
    slave->sii.name = NULL;
    memset(&slave->sii.coe_details, 0x00, sizeof(ec_sii_coe_details_t));
    memset(&slave->sii.general_flags, 0x00, sizeof(ec_sii_general_flags_t));
    slave->sii.current_on_ebus = 0;

    slave->sii.syncs = NULL;
    slave->sii.sync_count = 0;

    INIT_LIST_HEAD(&slave->sii.pdos);

    INIT_LIST_HEAD(&slave->sdo_dictionary);

    slave->sdo_dictionary_fetched = 0;
    slave->jiffies_preop = 0;

    INIT_LIST_HEAD(&slave->sdo_requests);
    INIT_LIST_HEAD(&slave->reg_requests);
    INIT_LIST_HEAD(&slave->foe_requests);
    INIT_LIST_HEAD(&slave->soe_requests);
    INIT_LIST_HEAD(&slave->eoe_requests);

    // create state machine object
    ec_fsm_slave_init(&slave->fsm, slave);

    slave->read_mbox_busy = 0;

#ifdef EC_EOE
    ec_mbox_data_init(&slave->mbox_eoe_data);
#endif
    ec_mbox_data_init(&slave->mbox_coe_data);
    ec_mbox_data_init(&slave->mbox_foe_data);
    ec_mbox_data_init(&slave->mbox_soe_data);
    ec_mbox_data_init(&slave->mbox_voe_data);

    slave->valid_mbox_data = 0;
}

/****************************************************************************/

void ec_read_mbox_lock_clear(ec_slave_t *slave)
{
    clear_bit_unlock(0, &slave->read_mbox_busy);
}

/****************************************************************************/

int ec_read_mbox_locked(ec_slave_t *slave)
{
    return test_and_set_bit_lock(0, &slave->read_mbox_busy);
}

/****************************************************************************/

void ec_slave_clear(ec_slave_t *slave )
{
    ec_sdo_t *sdo, *next_sdo;
    unsigned int i;
    ec_pdo_t *pdo, *next_pdo;

    // abort all pending requests

    while (!list_empty(&slave->sdo_requests)) {
        ec_sdo_request_t *request =
            list_entry(slave->sdo_requests.next, ec_sdo_request_t, list);
        list_del_init(&request->list); // dequeue
        EC_SLAVE_WARN(slave, "Discarding SDO request,"
                " slave about to be deleted.\n");
        request->state = EC_INT_REQUEST_FAILURE;
    }

    while (!list_empty(&slave->reg_requests)) {
        ec_reg_request_t *reg =
            list_entry(slave->reg_requests.next, ec_reg_request_t, list);
        list_del_init(&reg->list); // dequeue
        EC_SLAVE_WARN(slave, "Discarding register request,"
                " slave about to be deleted.\n");
        reg->state = EC_INT_REQUEST_FAILURE;
    }

    while (!list_empty(&slave->foe_requests)) {
        ec_foe_request_t *request =
            list_entry(slave->foe_requests.next, ec_foe_request_t, list);
        list_del_init(&request->list); // dequeue
        EC_SLAVE_WARN(slave, "Discarding FoE request,"
                " slave about to be deleted.\n");
        request->state = EC_INT_REQUEST_FAILURE;
    }

    while (!list_empty(&slave->soe_requests)) {
        ec_soe_request_t *request =
            list_entry(slave->soe_requests.next, ec_soe_request_t, list);
        list_del_init(&request->list); // dequeue
        EC_SLAVE_WARN(slave, "Discarding SoE request,"
                " slave about to be deleted.\n");
        request->state = EC_INT_REQUEST_FAILURE;
    }

#ifdef EC_EOE
    while (!list_empty(&slave->eoe_requests)) {
        ec_eoe_request_t *request =
            list_entry(slave->eoe_requests.next, ec_eoe_request_t, list);
        list_del_init(&request->list); // dequeue
        EC_SLAVE_WARN(slave, "Discarding EoE request,"
                " slave about to be deleted.\n");
        request->state = EC_INT_REQUEST_FAILURE;
    }
#endif

    wake_up_all(&slave->master->request_queue);

    if (slave->config) {
        ec_slave_config_detach(slave->config);
    }

    // free all SDOs
    list_for_each_entry_safe(sdo, next_sdo, &slave->sdo_dictionary, list) {
        list_del(&sdo->list);
        ec_sdo_clear(sdo);
        kfree(sdo);
    }

    // free all strings
    if (slave->sii.strings) {
        for (i = 0; i < slave->sii.string_count; i++)
            kfree(slave->sii.strings[i]);
        kfree(slave->sii.strings);
    }

    // free all sync managers
    ec_slave_clear_sync_managers(slave);

    // free all SII PDOs
    list_for_each_entry_safe(pdo, next_pdo, &slave->sii.pdos, list) {
        list_del(&pdo->list);
        ec_pdo_clear(pdo);
        kfree(pdo);
    }

    ec_sii_page_clear(&slave->sii_page);

    // free mailbox response data
#ifdef EC_EOE
    ec_mbox_data_clear(&slave->mbox_eoe_data);
#endif
    ec_mbox_data_clear(&slave->mbox_coe_data);
    ec_mbox_data_clear(&slave->mbox_foe_data);
    ec_mbox_data_clear(&slave->mbox_soe_data);
    ec_mbox_data_clear(&slave->mbox_voe_data);

    ec_fsm_slave_clear(&slave->fsm);
}

/****************************************************************************/

void ec_slave_clear_sync_managers(ec_slave_t *slave )
{
    unsigned int i;

    if (slave->sii.syncs) {
        for (i = 0; i < slave->sii.sync_count; i++) {
            ec_sync_clear(&slave->sii.syncs[i]);
        }
        kfree(slave->sii.syncs);
        slave->sii.syncs = NULL;
    }
}

/****************************************************************************/

void ec_slave_set_state(ec_slave_t *slave, 
        ec_slave_state_t new_state 
        )
{
    if (new_state != slave->current_state) {
        if (slave->master->debug_level) {
            char old_state[EC_STATE_STRING_SIZE],
                cur_state[EC_STATE_STRING_SIZE];
            ec_state_string(slave->current_state, old_state, 0);
            ec_state_string(new_state, cur_state, 0);
            EC_SLAVE_DBG(slave, 0, "%s -> %s.\n", old_state, cur_state);
        }
        slave->current_state = new_state;
    }
}

/****************************************************************************/

void ec_slave_request_state(ec_slave_t *slave, 
                            ec_slave_state_t state 
                            )
{
    slave->requested_state = state;
    slave->error_flag = 0;
}

/****************************************************************************/

int ec_slave_analyze_sii_data(
        ec_slave_t *slave 
        )
{
    uint16_t *cat_word, cat_type, cat_size;
    int ret;

    ec_slave_clear_sync_managers(slave);

    slave->sii.alias =
        EC_READ_U16(slave->sii_page.words + EC_SII_WORD_OFFSET_ALIAS);
    slave->effective_alias = slave->sii.alias;
    slave->sii_page.alias = slave->sii.alias;

    slave->sii.vendor_id =
        EC_READ_U32(slave->sii_page.words + EC_SII_WORD_OFFSET_VENDOR);
    slave->sii_page.vendor_id = slave->sii.vendor_id;

    slave->sii.product_code =
        EC_READ_U32(slave->sii_page.words + 0x000A);
    slave->sii_page.product_code = slave->sii.product_code;

    slave->sii.revision_number =
        EC_READ_U32(slave->sii_page.words + 0x000C);
    slave->sii_page.revision_number = slave->sii.revision_number;

    slave->sii.serial_number =
        EC_READ_U32(slave->sii_page.words + 0x000E);
    slave->sii_page.serial_number = slave->sii.serial_number;

    slave->sii.boot_rx_mailbox_offset =
        EC_READ_U16(slave->sii_page.words + 0x0014);
    slave->sii.boot_rx_mailbox_size =
        EC_READ_U16(slave->sii_page.words + 0x0015);
    slave->sii.boot_tx_mailbox_offset =
        EC_READ_U16(slave->sii_page.words + 0x0016);
    slave->sii.boot_tx_mailbox_size =
        EC_READ_U16(slave->sii_page.words + 0x0017);
    slave->sii.std_rx_mailbox_offset =
        EC_READ_U16(slave->sii_page.words + 0x0018);
    slave->sii.std_rx_mailbox_size =
        EC_READ_U16(slave->sii_page.words + 0x0019);
    slave->sii.std_tx_mailbox_offset =
        EC_READ_U16(slave->sii_page.words + 0x001A);
    slave->sii.std_tx_mailbox_size =
        EC_READ_U16(slave->sii_page.words + 0x001B);
    slave->sii.mailbox_protocols =
        EC_READ_U16(slave->sii_page.words + 0x001C);
    if (slave->sii.mailbox_protocols) {
        int need_delim = 0;
        uint16_t all = EC_MBOX_AOE | EC_MBOX_COE | EC_MBOX_FOE |
            EC_MBOX_SOE | EC_MBOX_VOE;
        if ((slave->sii.mailbox_protocols & all) &&
                slave->master->debug_level >= 1) {
            EC_SLAVE_DBG(slave, 1, "Slave announces to support ");
            if (slave->sii.mailbox_protocols & EC_MBOX_AOE) {
                printk(KERN_CONT "AoE");
                need_delim = 1;
            }
            if (slave->sii.mailbox_protocols & EC_MBOX_COE) {
                if (need_delim) {
                    printk(KERN_CONT ", ");
                }
                printk(KERN_CONT "CoE");
                need_delim = 1;
            }
            if (slave->sii.mailbox_protocols & EC_MBOX_FOE) {
                if (need_delim) {
                    printk(KERN_CONT ", ");
                }
                printk(KERN_CONT "FoE");
                need_delim = 1;
            }
            if (slave->sii.mailbox_protocols & EC_MBOX_SOE) {
                if (need_delim) {
                    printk(KERN_CONT ", ");
                }
                printk(KERN_CONT "SoE");
                need_delim = 1;
            }
            if (slave->sii.mailbox_protocols & EC_MBOX_VOE) {
                if (need_delim) {
                    printk(KERN_CONT ", ");
                }
                printk(KERN_CONT "VoE");
                need_delim = 1;
            }
            printk(KERN_CONT ".\n");
        }
        if (slave->sii.mailbox_protocols & ~all) {
            EC_SLAVE_DBG(slave, 1, "Slave announces to support unknown"
                    " mailbox protocols 0x%04X.",
                    slave->sii.mailbox_protocols & ~all);
        }
    }
    else {
        EC_SLAVE_DBG(slave, 1, "Slave announces to support no mailbox"
                " protocols.");
    }

    if (slave->sii.boot_rx_mailbox_offset == 0xffff ||
            slave->sii.boot_rx_mailbox_size == 0xffff ||
            slave->sii.boot_tx_mailbox_offset == 0xffff ||
            slave->sii.boot_tx_mailbox_size == 0xffff ||
            slave->sii.std_rx_mailbox_offset == 0xffff ||
            slave->sii.std_rx_mailbox_size == 0xffff ||
            slave->sii.std_tx_mailbox_offset == 0xffff ||
            slave->sii.std_tx_mailbox_size == 0xffff) {
        slave->sii.mailbox_protocols = 0x0000;
        EC_SLAVE_ERR(slave, "Invalid mailbox settings in SII."
                " Disabling mailbox communication.");
    }

    if (slave->sii_page.word_count == EC_FIRST_SII_CATEGORY_OFFSET) {
        // SII does not contain category data
        return 0;
    }

    if (slave->sii_page.word_count < EC_FIRST_SII_CATEGORY_OFFSET + 1) {
        EC_SLAVE_ERR(slave, "Unexpected end of SII data:"
                " First category header missing.\n");
        return -ENOENT;
    }

    // evaluate category data
    cat_word = slave->sii_page.words + EC_FIRST_SII_CATEGORY_OFFSET;
    while (EC_READ_U16(cat_word) != 0xFFFF) {
        // type and size words must fit
        if (cat_word + 2 - slave->sii_page.words
                > slave->sii_page.word_count) {
            EC_SLAVE_ERR(slave, "Unexpected end of SII data:"
                    " Category header incomplete.\n");
            return -ENOENT;
        }

        cat_type = EC_READ_U16(cat_word) & 0x7FFF;
        cat_size = EC_READ_U16(cat_word + 1);
        cat_word += 2;

        if (cat_word + cat_size - slave->sii_page.words
                > slave->sii_page.word_count) {
            EC_SLAVE_WARN(slave, "Unexpected end of SII data:"
                    " Category data incomplete.\n");
            return -ENOENT;
        }

        switch (cat_type) {
            case 0x000A:
                ret = ec_slave_fetch_sii_strings(slave, (uint8_t *) cat_word,
                            cat_size * 2);
                if (ret) {
                    return ret;
                }
                break;

            case 0x001E:
                ret = ec_slave_fetch_sii_general(slave, (uint8_t *) cat_word,
                            cat_size * 2);
                if (ret) {
                    return ret;
                }
                break;

            case 0x0028:
                break;

            case 0x0029:
                ret = ec_slave_fetch_sii_syncs(slave, (uint8_t *) cat_word,
                            cat_size * 2);
                if (ret) {
                    return ret;
                }
                break;

            case 0x0032:
                ret = ec_slave_fetch_sii_pdos(slave, (uint8_t *) cat_word,
                            cat_size * 2, EC_DIR_INPUT); // TxPDO
                if (ret) {
                    return ret;
                }
                break;

            case 0x0033:
                ret = ec_slave_fetch_sii_pdos(slave, (uint8_t *) cat_word,
                            cat_size * 2, EC_DIR_OUTPUT); // RxPDO
                if (ret) {
                    return ret;
                }
                break;

            default:
                EC_SLAVE_DBG(slave, 1, "Unknown category type 0x%04X.\n",
                        cat_type);
        }

        cat_word += cat_size;
        if (cat_word - slave->sii_page.words >= slave->sii_page.word_count) {
            EC_SLAVE_WARN(slave, "Unexpected end of SII data:"
                    " Next category header missing.\n");
            return -ENOENT;
        }
    }

    return 0;
}

/****************************************************************************/

int ec_slave_fetch_sii_strings(
        ec_slave_t *slave, 
        const uint8_t *data, 
        size_t data_size 
        )
{
    int i, err;
    size_t size;
    off_t offset;

    slave->sii.string_count = data[0];

    if (slave->sii.string_count) {
        if (!(slave->sii.strings =
                    kmalloc(sizeof(char *) * slave->sii.string_count,
                        GFP_KERNEL))) {
            EC_SLAVE_ERR(slave, "Failed to allocate string array memory.\n");
            err = -ENOMEM;
            goto out_zero;
        }

        offset = 1;
        for (i = 0; i < slave->sii.string_count; i++) {
            size = data[offset];
            // allocate memory for string structure and data at a single blow
            if (!(slave->sii.strings[i] =
                        kmalloc(sizeof(char) * size + 1, GFP_KERNEL))) {
                EC_SLAVE_ERR(slave, "Failed to allocate string memory.\n");
                err = -ENOMEM;
                goto out_free;
            }
            memcpy(slave->sii.strings[i], data + offset + 1, size);
            slave->sii.strings[i][size] = 0x00; // append binary zero
            offset += 1 + size;
        }
    }

    return 0;

out_free:
    for (i--; i >= 0; i--)
        kfree(slave->sii.strings[i]);
    kfree(slave->sii.strings);
    slave->sii.strings = NULL;
out_zero:
    slave->sii.string_count = 0;
    return err;
}

/****************************************************************************/

int ec_slave_fetch_sii_general(
        ec_slave_t *slave, 
        const uint8_t *data, 
        size_t data_size 
        )
{
    unsigned int i;
    uint8_t flags;

    if (data_size != 32) {
        EC_SLAVE_ERR(slave, "Wrong size of general category (%zu/32).\n",
                data_size);
        return -EINVAL;
    }

    slave->sii.group = ec_slave_sii_string(slave, data[0]);
    slave->sii.image = ec_slave_sii_string(slave, data[1]);
    slave->sii.order = ec_slave_sii_string(slave, data[2]);
    slave->sii.name = ec_slave_sii_string(slave, data[3]);

    for (i = 0; i < 4; i++)
        slave->sii.physical_layer[i] =
            (data[4] & (0x03 << (i * 2))) >> (i * 2);

    // read CoE details
    flags = EC_READ_U8(data + 5);
    slave->sii.coe_details.enable_sdo =                 (flags >> 0) & 0x01;
    slave->sii.coe_details.enable_sdo_info =            (flags >> 1) & 0x01;
    slave->sii.coe_details.enable_pdo_assign =          (flags >> 2) & 0x01;
    slave->sii.coe_details.enable_pdo_configuration =   (flags >> 3) & 0x01;
    slave->sii.coe_details.enable_upload_at_startup =   (flags >> 4) & 0x01;
    slave->sii.coe_details.enable_sdo_complete_access = (flags >> 5) & 0x01;

    // read general flags
    flags = EC_READ_U8(data + 0x000B);
    slave->sii.general_flags.enable_safeop =  (flags >> 0) & 0x01;
    slave->sii.general_flags.enable_not_lrw = (flags >> 1) & 0x01;

    slave->sii.current_on_ebus = EC_READ_S16(data + 0x0C);
    slave->sii.has_general = 1;
    return 0;
}

/****************************************************************************/

int ec_slave_fetch_sii_syncs(
        ec_slave_t *slave, 
        const uint8_t *data, 
        size_t data_size 
        )
{
    unsigned int i, count, total_count;
    ec_sync_t *sync;
    size_t memsize;
    ec_sync_t *syncs;
    uint8_t index;

    // one sync manager struct is 4 words long
    if (data_size % 8) {
        EC_SLAVE_ERR(slave, "Invalid SII sync manager category size %zu.\n",
                data_size);
        return -EINVAL;
    }

    count = data_size / 8;

    if (count) {
        total_count = count + slave->sii.sync_count;
        if (total_count > EC_MAX_SYNC_MANAGERS) {
            EC_SLAVE_ERR(slave, "Exceeded maximum number of"
                    " sync managers!\n");
            return -EOVERFLOW;
        }
        memsize = sizeof(ec_sync_t) * total_count;
        if (!(syncs = kmalloc(memsize, GFP_KERNEL))) {
            EC_SLAVE_ERR(slave, "Failed to allocate %zu bytes"
                    " for sync managers.\n", memsize);
            return -ENOMEM;
        }

        for (i = 0; i < slave->sii.sync_count; i++)
            ec_sync_init_copy(syncs + i, slave->sii.syncs + i);

        // initialize new sync managers
        for (i = 0; i < count; i++, data += 8) {
            index = i + slave->sii.sync_count;
            sync = &syncs[index];

            ec_sync_init(sync, slave);
            sync->physical_start_address = EC_READ_U16(data);
            sync->default_length = EC_READ_U16(data + 2);
            sync->control_register = EC_READ_U8(data + 4);
            sync->enable = EC_READ_U8(data + 6);
        }

        if (slave->sii.syncs)
            kfree(slave->sii.syncs);
        slave->sii.syncs = syncs;
        slave->sii.sync_count = total_count;
    }

    return 0;
}

/****************************************************************************/

int ec_slave_fetch_sii_pdos(
        ec_slave_t *slave, 
        const uint8_t *data, 
        size_t data_size, 
        ec_direction_t dir 
        )
{
    int ret;
    ec_pdo_t *pdo;
    ec_pdo_entry_t *entry;
    unsigned int entry_count, i;

    while (data_size >= 8) {
        if (!(pdo = kmalloc(sizeof(ec_pdo_t), GFP_KERNEL))) {
            EC_SLAVE_ERR(slave, "Failed to allocate PDO memory.\n");
            return -ENOMEM;
        }

        ec_pdo_init(pdo);
        pdo->index = EC_READ_U16(data);
        entry_count = EC_READ_U8(data + 2);
        pdo->sync_index = EC_READ_U8(data + 3);
        ret = ec_pdo_set_name(pdo,
                ec_slave_sii_string(slave, EC_READ_U8(data + 5)));
        if (ret) {
            ec_pdo_clear(pdo);
            kfree(pdo);
            return ret;
        }
        list_add_tail(&pdo->list, &slave->sii.pdos);

        data_size -= 8;
        data += 8;

        for (i = 0; i < entry_count; i++) {
            if (!(entry = kmalloc(sizeof(ec_pdo_entry_t), GFP_KERNEL))) {
                EC_SLAVE_ERR(slave, "Failed to allocate PDO entry memory.\n");
                return -ENOMEM;
            }

            ec_pdo_entry_init(entry);
            entry->index = EC_READ_U16(data);
            entry->subindex = EC_READ_U8(data + 2);
            ret = ec_pdo_entry_set_name(entry,
                    ec_slave_sii_string(slave, EC_READ_U8(data + 3)));
            if (ret) {
                ec_pdo_entry_clear(entry);
                kfree(entry);
                return ret;
            }
            entry->bit_length = EC_READ_U8(data + 5);
            list_add_tail(&entry->list, &pdo->entries);

            data_size -= 8;
            data += 8;
        }

        // if sync manager index is positive, the PDO is mapped by default
        if (pdo->sync_index >= 0) {
            ec_sync_t *sync;

            if (!(sync = ec_slave_get_sync(slave, pdo->sync_index))) {
                EC_SLAVE_ERR(slave, "Invalid SM index %i for PDO 0x%04X.",
                        pdo->sync_index, pdo->index);
                return -ENOENT;
            }

            ret = ec_pdo_list_add_pdo_copy(&sync->pdos, pdo);
            if (ret)
                return ret;
        }
    }

    return 0;
}

/****************************************************************************/

char *ec_slave_sii_string(
        const ec_slave_t *slave, 
        unsigned int index 
        )
{
    if (!index--)
        return NULL;

    if (index >= slave->sii.string_count) {
        EC_SLAVE_DBG(slave, 1, "String %u not found.\n", index);
        return NULL;
    }

    return slave->sii.strings[index];
}

/****************************************************************************/

ec_sync_t *ec_slave_get_sync(
        ec_slave_t *slave, 
        uint8_t sync_index 
        )
{
    if (sync_index < slave->sii.sync_count) {
        return &slave->sii.syncs[sync_index];
    } else {
        return NULL;
    }
}

/****************************************************************************/

void ec_slave_sdo_dict_info(const ec_slave_t *slave, 
                            unsigned int *sdo_count, 
                            unsigned int *entry_count 
                            )
{
    unsigned int sdos = 0, entries = 0;
    ec_sdo_t *sdo;
    ec_sdo_entry_t *entry;

    list_for_each_entry(sdo, &slave->sdo_dictionary, list) {
        sdos++;
        list_for_each_entry(entry, &sdo->entries, list) {
            entries++;
        }
    }

    *sdo_count = sdos;
    *entry_count = entries;
}

/****************************************************************************/

ec_sdo_t *ec_slave_get_sdo(
        ec_slave_t *slave, 
        uint16_t index 
        )
{
    ec_sdo_t *sdo;

    list_for_each_entry(sdo, &slave->sdo_dictionary, list) {
        if (sdo->index != index)
            continue;
        return sdo;
    }

    return NULL;
}

/****************************************************************************/

const ec_sdo_t *ec_slave_get_sdo_const(
        const ec_slave_t *slave, 
        uint16_t index 
        )
{
    const ec_sdo_t *sdo;

    list_for_each_entry(sdo, &slave->sdo_dictionary, list) {
        if (sdo->index != index)
            continue;
        return sdo;
    }

    return NULL;
}

/****************************************************************************/

const ec_sdo_t *ec_slave_get_sdo_by_pos_const(
        const ec_slave_t *slave, 
        uint16_t sdo_position 
        )
{
    const ec_sdo_t *sdo;

    list_for_each_entry(sdo, &slave->sdo_dictionary, list) {
        if (sdo_position--)
            continue;
        return sdo;
    }

    return NULL;
}

/****************************************************************************/

uint16_t ec_slave_sdo_count(
        const ec_slave_t *slave 
        )
{
    const ec_sdo_t *sdo;
    uint16_t count = 0;

    list_for_each_entry(sdo, &slave->sdo_dictionary, list) {
        count++;
    }

    return count;
}

/****************************************************************************/

const ec_pdo_t *ec_slave_find_pdo(
        const ec_slave_t *slave, 
        uint16_t index 
        )
{
    unsigned int i;
    const ec_sync_t *sync;
    const ec_pdo_t *pdo;

    for (i = 0; i < slave->sii.sync_count; i++) {
        sync = &slave->sii.syncs[i];

        if (!(pdo = ec_pdo_list_find_pdo_const(&sync->pdos, index)))
            continue;

        return pdo;
    }

    return NULL;
}

/****************************************************************************/

void ec_slave_find_names_for_pdo(
        ec_slave_t *slave,
        ec_pdo_t *pdo
        )
{
    const ec_sdo_t *sdo;
    ec_pdo_entry_t *pdo_entry;
    const ec_sdo_entry_t *sdo_entry;

    list_for_each_entry(sdo, &slave->sdo_dictionary, list) {
        if (sdo->index == pdo->index) {
            ec_pdo_set_name(pdo, sdo->name);
        } else {
            list_for_each_entry(pdo_entry, &pdo->entries, list) {
                if (sdo->index == pdo_entry->index) {
                    sdo_entry = ec_sdo_get_entry_const(
                            sdo, pdo_entry->subindex);
                    if (sdo_entry) {
                        ec_pdo_entry_set_name(pdo_entry,
                                sdo_entry->description);
                    }
                }
            }
        }
    }
}

/****************************************************************************/

void ec_slave_attach_pdo_names(
        ec_slave_t *slave
        )
{
    unsigned int i;
    ec_sync_t *sync;
    ec_pdo_t *pdo;

    for (i = 0; i < slave->sii.sync_count; i++) {
        sync = slave->sii.syncs + i;
        list_for_each_entry(pdo, &sync->pdos.list, list) {
            ec_slave_find_names_for_pdo(slave, pdo);
        }
    }
}

/****************************************************************************/

unsigned int ec_slave_get_previous_port(
        const ec_slave_t *slave, 
        unsigned int port_index 
        )
{
    static const unsigned int prev_table[EC_MAX_PORTS] = {
        2, 3, 1, 0
    };

    if (port_index >= EC_MAX_PORTS) {
        EC_SLAVE_WARN(slave, "%s(port_index=%u): Invalid port index!\n",
                __func__, port_index);
    }

    do {
        port_index = prev_table[port_index];
        if (slave->ports[port_index].next_slave) {
            return port_index;
        }
    } while (port_index);

    return 0;
}

/****************************************************************************/

unsigned int ec_slave_get_next_port(
        const ec_slave_t *slave, 
        unsigned int port_index 
        )
{
    static const unsigned int next_table[EC_MAX_PORTS] = {
        3, 2, 0, 1
    };

    if (port_index >= EC_MAX_PORTS) {
        EC_SLAVE_WARN(slave, "%s(port_index=%u): Invalid port index!\n",
                __func__, port_index);
    }

    do {
        port_index = next_table[port_index];
        if (slave->ports[port_index].next_slave) {
            return port_index;
        }
    } while (port_index);

    return 0;
}

/****************************************************************************/

uint32_t ec_slave_calc_rtt_sum(
        const ec_slave_t *slave 
        )
{
    uint32_t rtt_sum = 0, rtt;
    unsigned int port_index = ec_slave_get_next_port(slave, 0);

    while (port_index != 0) {
        unsigned int prev_index =
            ec_slave_get_previous_port(slave, port_index);

        rtt = slave->ports[port_index].receive_time -
            slave->ports[prev_index].receive_time;
        rtt_sum += rtt;
        port_index = ec_slave_get_next_port(slave, port_index);
    }

    return rtt_sum;
}

/****************************************************************************/

ec_slave_t *ec_slave_find_next_dc_slave(
        ec_slave_t *slave 
        )
{
    unsigned int port_index;
    ec_slave_t *dc_slave = NULL;

    if (slave->base_dc_supported) {
        dc_slave = slave;
    } else {
        port_index = ec_slave_get_next_port(slave, 0);

        while (port_index != 0) {
            ec_slave_t *next = slave->ports[port_index].next_slave;

            if (next) {
                dc_slave = ec_slave_find_next_dc_slave(next);

                if (dc_slave) {
                    break;
                }
            }
            port_index = ec_slave_get_next_port(slave, port_index);
        }
    }

    return dc_slave;
}

/****************************************************************************/

void ec_slave_calc_port_delays(
        ec_slave_t *slave 
        )
{
    unsigned int port_index;
    ec_slave_t *next_slave, *next_dc;
    uint32_t rtt, next_rtt_sum;

    if (!slave->base_dc_supported)
        return;

    port_index = ec_slave_get_next_port(slave, 0);

    while (port_index != 0) {
        next_slave = slave->ports[port_index].next_slave;
        next_dc = ec_slave_find_next_dc_slave(next_slave);

        if (next_dc) {
            unsigned int prev_port =
                ec_slave_get_previous_port(slave, port_index);

            rtt = slave->ports[port_index].receive_time -
                slave->ports[prev_port].receive_time;
            next_rtt_sum = ec_slave_calc_rtt_sum(next_dc);

            slave->ports[port_index].delay_to_next_dc =
                (rtt - next_rtt_sum) / 2; // FIXME
            next_dc->ports[0].delay_to_next_dc =
                (rtt - next_rtt_sum) / 2;

#if 0
            EC_SLAVE_DBG(slave, 1, "delay %u:%u rtt=%u"
                    " next_rtt_sum=%u delay=%u\n",
                    slave->ring_position, port_index, rtt, next_rtt_sum,
                    slave->ports[port_index].delay_to_next_dc);
#endif
        }

        port_index = ec_slave_get_next_port(slave, port_index);
    }
}

/****************************************************************************/

void ec_slave_calc_transmission_delays_rec(
        ec_slave_t *slave, 
        ec_slave_t *came_from, 
        uint32_t *delay 
        )
{
    unsigned int i, first;
    ec_slave_t *next_dc;

    EC_SLAVE_DBG(slave, 1, "%s(delay = %u ns)\n", __func__, *delay);

    slave->transmission_delay = *delay;

    // Visit every open port in frame-traversal order (downstream ports
    // first, the master-facing upstream port last), skipping the port we
    // arrived through. Link delays are symmetric, so each edge adds the
    // same amount whether descended or ascended, and the round-trip is
    // accounted by adding the edge delay both before and after recursing.
    // Starting the walk at the reference clock and allowing the upstream
    // direction re-roots the delay tree at the reference, so slaves
    // upstream of a non-default reference get recomputed too (previously
    // they kept stale delays from the old default).
    first = ec_slave_get_next_port(slave, 0);
    i = first;

    do {
        ec_slave_port_t *port = &slave->ports[i];
        // ec_slave_get_next_port() falls back to port 0 when no
        // further connected port exists; on the first slave that port faces
        // the master and has no next_slave. Also skip a next_dc that resolves
        // back to ourselves (possible when ascending through a non-DC slave,
        // whose downstream search would find us again).
        next_dc = port->next_slave ?
            ec_slave_find_next_dc_slave(port->next_slave) : NULL;
        if (next_dc && next_dc != came_from && next_dc != slave) {
            *delay = *delay + port->delay_to_next_dc;
#if 0
            EC_SLAVE_DBG(slave, 1, "%u:%u %u\n",
                    slave->ring_position, i, *delay);
#endif
            ec_slave_calc_transmission_delays_rec(next_dc, slave, delay);
            *delay = *delay + port->delay_to_next_dc;
        }

        i = ec_slave_get_next_port(slave, i);
    } while (i != first);
}

/****************************************************************************/