slave.c

Go to the documentation of this file.

/******************************************************************************
 *
 *  $Id$
 *
 *  Copyright (C) 2006-2012  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
 *
 *  ---
 *
 *  The license mentioned above concerns the source code only. Using the
 *  EtherCAT technology and brand is only permitted in compliance with the
 *  industrial property and similar rights of Beckhoff Automation GmbH.
 *
 *****************************************************************************/

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

#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[];

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

char *ec_slave_sii_string(ec_slave_t *, unsigned int);

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

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;
#ifdef EC_SII_CACHE
    slave->effective_vendor_id = 0x00000000;
    slave->effective_product_code = 0x00000000;
    slave->effective_revision_number = 0x00000000;
    slave->effective_serial_number = 0x00000000;
#endif
    slave->config = NULL;
    slave->requested_state = EC_SLAVE_STATE_PREOP;
    slave->current_state = EC_SLAVE_STATE_UNKNOWN;
    slave->last_al_error = 0;
    slave->error_flag = 0;
    slave->force_config = 0;
    slave->reboot = 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 = 1;
        slave->ports[i].link.signal_detected = 0;
        slave->ports[i].link.bypassed = 0;

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

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

#ifdef EC_LOOP_CONTROL
        slave->ports[i].state = EC_SLAVE_PORT_DOWN;
        slave->ports[i].link_detection_jiffies = 0;
#endif
    }
    slave->upstream_port = 0;

    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;

    slave->vendor_words = NULL;
    slave->sii_image = NULL;


    INIT_LIST_HEAD(&slave->sdo_dictionary);

    slave->scan_required = 1;
    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);
    INIT_LIST_HEAD(&slave->mbg_requests);
    INIT_LIST_HEAD(&slave->dict_requests);

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

    slave->read_mbox_busy = 0;
    rt_mutex_init(&slave->mbox_sem);

#ifdef EC_EOE
    ec_mbox_data_init(&slave->mbox_eoe_frag_data);
    ec_mbox_data_init(&slave->mbox_eoe_init_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);
    ec_mbox_data_init(&slave->mbox_mbg_data);

    slave->valid_mbox_data = 0;
}


void ec_slave_sii_image_init(
        ec_sii_image_t *sii_image 
        )
{
    unsigned int i;

    sii_image->words = NULL;
    sii_image->nwords = 0;

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

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

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

    INIT_LIST_HEAD(&sii_image->sii.pdos);

    for (i = 0; i < EC_MAX_PORTS; i++) {
        sii_image->sii.physical_layer[i] = 0xFF;
    }
}

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

void ec_read_mbox_lock_clear(ec_slave_t *slave)
{
    rt_mutex_lock(&slave->mbox_sem);
    slave->read_mbox_busy = 0;
    rt_mutex_unlock(&slave->mbox_sem);
}


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

int ec_read_mbox_locked(ec_slave_t *slave)
{
    int rc;

    rt_mutex_lock(&slave->mbox_sem);
    rc = slave->read_mbox_busy;
    if (!slave->read_mbox_busy) {
        slave->read_mbox_busy = 1;
    }
    rt_mutex_unlock(&slave->mbox_sem);
    return rc;
}


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

void ec_slave_clear(ec_slave_t *slave )
{
    ec_sdo_t *sdo, *next_sdo;

    // 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;
    }

    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;
    }

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

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

    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);
    }

    if (slave->vendor_words) {
        kfree(slave->vendor_words);
        slave->vendor_words = NULL;
    }

    // free mailbox response data
#ifdef EC_EOE
    ec_mbox_data_clear(&slave->mbox_eoe_frag_data);
    ec_mbox_data_clear(&slave->mbox_eoe_init_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_mbox_data_clear(&slave->mbox_mbg_data);

    ec_fsm_slave_clear(&slave->fsm);
}

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

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

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

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

void ec_slave_set_dl_status(ec_slave_t *slave, 
        uint16_t new_state 
        )
{
    unsigned int i;
    uint8_t state;

    for (i = 0; i < EC_MAX_PORTS; i++) {
        // link status
        state = new_state & (1 << (4 + i)) ? 1 : 0;
        if (slave->ports[i].link.link_up != state) {
            EC_SLAVE_DBG(slave, 1, "Port %u link status changed to %s.\n",
                    i, state ? "up" : "down");
            slave->ports[i].link.link_up = state;
        }

        // loop status
        state = new_state & (1 << (8 + i * 2)) ? 1 : 0;
        if (slave->ports[i].link.loop_closed != state) {
            EC_SLAVE_DBG(slave, 1, "Port %u loop status changed to %s.\n",
                    i, state ? "closed" : "open");
            slave->ports[i].link.loop_closed = state;
        }

        // signal detection
        state = new_state & (1 << (9 + i * 2)) ? 1 : 0;
        if (slave->ports[i].link.signal_detected != state) {
            EC_SLAVE_DBG(slave, 1, "Port %u signal status changed to %s.\n",
                    i, state ? "yes" : "no");
            slave->ports[i].link.signal_detected = state;
        }
    }
}

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

void ec_slave_set_al_status(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;
}

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

void ec_slave_request_reboot(ec_slave_t *slave 
                            )
{
    slave->reboot = 1;
}

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

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;

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return -EINVAL;
    }

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

    if (slave->sii_image->sii.string_count) {
        if (!(slave->sii_image->sii.strings =
                    kmalloc(sizeof(char *) * slave->sii_image->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_image->sii.string_count; i++) {
            size = data[offset];
            // allocate memory for string structure and data at a single blow
            if (!(slave->sii_image->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_image->sii.strings[i], data + offset + 1, size);
            slave->sii_image->sii.strings[i][size] = 0x00; // append binary zero
            offset += 1 + size;
        }
    }

    return 0;

out_free:
    for (i--; i >= 0; i--)
        kfree(slave->sii_image->sii.strings[i]);
    kfree(slave->sii_image->sii.strings);
    slave->sii_image->sii.strings = NULL;
out_zero:
    slave->sii_image->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;
    }

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return -EINVAL;
    }

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

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

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

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

    slave->sii_image->sii.current_on_ebus = EC_READ_S16(data + 0x0C);
    slave->sii_image->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;
    }

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return -EINVAL;
    }

    count = data_size / 8;

    if (count) {
        total_count = count + slave->sii_image->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_image->sii.sync_count; i++)
            ec_sync_init_copy(syncs + i, slave->sii_image->sii.syncs + i);

        // initialize new sync managers
        for (i = 0; i < count; i++, data += 8) {
            index = i + slave->sii_image->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_image->sii.syncs)
            kfree(slave->sii_image->sii.syncs);
        slave->sii_image->sii.syncs = syncs;
        slave->sii_image->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;

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return -EINVAL;
    }

    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_image->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(
        ec_slave_t *slave, 
        unsigned int index 
        )
{
    if (!index--)
        return NULL;

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return NULL;
    }

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

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

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

ec_sync_t *ec_slave_get_sync(
        ec_slave_t *slave, 
        uint8_t sync_index 
        )
{

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return NULL;
    }

    if (sync_index < slave->sii_image->sii.sync_count) {
        return &slave->sii_image->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;

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return NULL;
    }

    for (i = 0; i < slave->sii_image->sii.sync_count; i++) {
        sync = &slave->sii_image->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;

    if (!slave->sii_image) {
        EC_SLAVE_ERR(slave, "SII data not attached!\n");
        return;
    }

    for (i = 0; i < slave->sii_image->sii.sync_count; i++) {
        sync = slave->sii_image->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(
        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 != slave->upstream_port);

    return slave->upstream_port;
}

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

unsigned int ec_slave_get_previous_normal_port(
        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].link.bypassed &&
                slave->ports[port_index].next_slave) {
            return port_index;
        }
    } while (port_index != slave->upstream_port);

    return slave->upstream_port;
}

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

unsigned int ec_slave_get_next_port(
        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 != slave->upstream_port);

    return slave->upstream_port;
}

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

void ec_slave_calc_upstream_port(
        ec_slave_t *slave 
        )
{
    int i, replace;

    // initially assume it's port 0 (normal connection order)
    slave->upstream_port = 0;
    replace = slave->ports[0].link.loop_closed || slave->ports[0].link.bypassed;

    if (!slave->base_dc_supported) {
        // we can't tell any better for non-DC slaves; assume we're right
        EC_SLAVE_DBG(slave, 1, "DC not supported; assuming upstream port 0.\n");
        return;
    }

    // any open & non-bypassed port with a lower receive time
    // is a better candidate for the upstream port
    for (i = 1; i < EC_MAX_PORTS; ++i) {
        if (!slave->ports[i].link.loop_closed &&
                !slave->ports[i].link.bypassed) {
            int32_t diff = slave->ports[i].receive_time -
                slave->ports[slave->upstream_port].receive_time;
            if (diff < 0 || replace) {
                slave->upstream_port = i;
                replace = 0;
            }
        }
    }
    EC_SLAVE_DBG(slave, 1, "upstream port = %u\n", slave->upstream_port);
}

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

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

    while (port_index != slave->upstream_port) {
        unsigned int prev_index =
            ec_slave_get_previous_normal_port(slave, port_index);

        if (!slave->ports[port_index].link.bypassed) {
            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, slave->upstream_port);

        while (port_index != slave->upstream_port) {
            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, slave->upstream_port);

    while (port_index != slave->upstream_port) {
        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_normal_port(slave, port_index);

            if (!slave->ports[port_index].link.bypassed) {
                rtt = slave->ports[port_index].receive_time -
                    slave->ports[prev_port].receive_time;
            } else {
                rtt = 0; // FIXME
            }
            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[next_dc->upstream_port].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, 
        uint32_t *delay 
        )
{
    unsigned int i;
    ec_slave_t *next_dc;

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

    slave->transmission_delay = *delay;

    i = ec_slave_get_next_port(slave, slave->upstream_port);

    while (i != slave->upstream_port) {
        ec_slave_port_t *port = &slave->ports[i];
        next_dc = ec_slave_find_next_dc_slave(port->next_slave);
        if (next_dc) {
            *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, delay);
        }

        i = ec_slave_get_next_port(slave, i);
    }

    *delay = *delay + slave->ports[slave->upstream_port].delay_to_next_dc;
}

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