fsm_master.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 "globals.h"
#include "master.h"
#include "mailbox.h"
#include "slave_config.h"
#ifdef EC_EOE
#include "ethernet.h"
#endif

#include "fsm_master.h"
#include "fsm_foe.h"

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

#define EC_SYSTEM_TIME_TOLERANCE_NS 1000

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

void ec_fsm_master_state_start(ec_fsm_master_t *);
void ec_fsm_master_state_broadcast(ec_fsm_master_t *);
void ec_fsm_master_state_read_al_status(ec_fsm_master_t *);
#ifdef EC_LOOP_CONTROL
void ec_fsm_master_state_read_dl_status(ec_fsm_master_t *);
void ec_fsm_master_state_open_port(ec_fsm_master_t *);
#endif
void ec_fsm_master_state_dc_read_old_times(ec_fsm_master_t *);
void ec_fsm_master_state_clear_addresses(ec_fsm_master_t *);
#ifdef EC_LOOP_CONTROL
void ec_fsm_master_state_loop_control(ec_fsm_master_t *);
#endif
void ec_fsm_master_state_dc_measure_delays(ec_fsm_master_t *);
void ec_fsm_master_state_scan_slave(ec_fsm_master_t *);
void ec_fsm_master_state_dc_read_offset(ec_fsm_master_t *);
void ec_fsm_master_state_dc_write_offset(ec_fsm_master_t *);
void ec_fsm_master_state_dc_reset_filter(ec_fsm_master_t *);
void ec_fsm_master_state_write_sii(ec_fsm_master_t *);
void ec_fsm_master_state_reboot_slave(ec_fsm_master_t *);

void ec_fsm_master_enter_dc_read_old_times(ec_fsm_master_t *);
void ec_fsm_master_enter_clear_addresses(ec_fsm_master_t *);
void ec_fsm_master_enter_write_system_times(ec_fsm_master_t *);

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

void ec_fsm_master_init(
        ec_fsm_master_t *fsm, 
        ec_master_t *master, 
        ec_datagram_t *datagram 
        )
{
    fsm->master = master;
    fsm->datagram = datagram;

    ec_fsm_master_reset(fsm);

    // init sub-state-machines
    ec_fsm_reboot_init(&fsm->fsm_reboot, fsm->datagram);
    ec_fsm_sii_init(&fsm->fsm_sii);
}

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

void ec_fsm_master_clear(
        ec_fsm_master_t *fsm 
        )
{
    // clear sub-state machines
    ec_fsm_reboot_clear(&fsm->fsm_reboot);
    ec_fsm_sii_clear(&fsm->fsm_sii);
}

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

void ec_fsm_master_reset(
        ec_fsm_master_t *fsm 
        )
{
    ec_device_index_t dev_idx;

    fsm->state = ec_fsm_master_state_start;
    fsm->idle = 0;
    fsm->dev_idx = EC_DEVICE_MAIN;

    for (dev_idx = EC_DEVICE_MAIN;
            dev_idx < ec_master_num_devices(fsm->master); dev_idx++) {
        fsm->link_state[dev_idx] = 0;
        fsm->slaves_responding[dev_idx] = 0;
        fsm->slave_states[dev_idx] = EC_SLAVE_STATE_UNKNOWN;
    }

    fsm->rescan_required = 0;
}

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

int ec_fsm_master_exec(
        ec_fsm_master_t *fsm 
        )
{
    if (fsm->datagram->state == EC_DATAGRAM_SENT
        || fsm->datagram->state == EC_DATAGRAM_QUEUED) {
        // datagram was not sent or received yet.
        return 0;
    }

    fsm->state(fsm);
    return 1;
}

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

int ec_fsm_master_idle(
        const ec_fsm_master_t *fsm 
        )
{
    return fsm->idle;
}

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

void ec_fsm_master_restart(
        ec_fsm_master_t *fsm 
        )
{
    fsm->dev_idx = EC_DEVICE_MAIN;
    fsm->state = ec_fsm_master_state_start;
    fsm->state(fsm); // execute immediately
}

/******************************************************************************
 * Master state machine
 *****************************************************************************/

void ec_fsm_master_state_start(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;

    fsm->idle = 1;

    // check for emergency requests
    if (!list_empty(&master->emerg_reg_requests)) {
        ec_reg_request_t *request;

        // get first request
        request = list_entry(master->emerg_reg_requests.next,
                ec_reg_request_t, list);
        list_del_init(&request->list); // dequeue
        request->state = EC_INT_REQUEST_BUSY;

        if (request->transfer_size > fsm->datagram->mem_size) {
            EC_MASTER_ERR(master, "Emergency request data too large!\n");
            request->state = EC_INT_REQUEST_FAILURE;
            wake_up_all(&master->request_queue);
            fsm->state(fsm); // continue
            return;
        }

        if (request->dir != EC_DIR_OUTPUT) {
            EC_MASTER_ERR(master, "Emergency requests must be"
                    " write requests!\n");
            request->state = EC_INT_REQUEST_FAILURE;
            wake_up_all(&master->request_queue);
            fsm->state(fsm); // continue
            return;
        }

        EC_MASTER_DBG(master, 1, "Writing emergency register request...\n");
        ec_datagram_apwr(fsm->datagram, request->ring_position,
                request->address, request->transfer_size);
        memcpy(fsm->datagram->data, request->data, request->transfer_size);
        fsm->datagram->device_index = EC_DEVICE_MAIN;
        request->state = EC_INT_REQUEST_SUCCESS;
        wake_up_all(&master->request_queue);
        return;
    }

    // check for detached config requests
    ec_master_expire_slave_config_requests(fsm->master);

    if (master->reboot) {
        // A reboot of all slaves was requested
        master->reboot = 0;
        fsm->idle = 0;
        fsm->state = ec_fsm_master_state_reboot_slave;
        fsm->slave = NULL;
        ec_fsm_reboot_all(&fsm->fsm_reboot, master);
        fsm->state(fsm); // execute immediately
        return;
    }

    ec_datagram_brd(fsm->datagram, 0x0130, 2);
    ec_datagram_zero(fsm->datagram);
    fsm->datagram->device_index = fsm->dev_idx;
    fsm->state = ec_fsm_master_state_broadcast;
}

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

void ec_fsm_master_state_broadcast(
        ec_fsm_master_t *fsm 
        )
{
    ec_datagram_t *datagram = fsm->datagram;
    unsigned int i, size;
    ec_slave_t *slave;
    ec_master_t *master = fsm->master;

    // bus topology change?
    if (datagram->working_counter != fsm->slaves_responding[fsm->dev_idx]) {
        fsm->rescan_required = 1;
        fsm->slaves_responding[fsm->dev_idx] = datagram->working_counter;
        EC_MASTER_INFO(master, "%u slave(s) responding on %s device.\n",
                fsm->slaves_responding[fsm->dev_idx],
                ec_device_names[fsm->dev_idx != 0]);
    }

    if (fsm->link_state[fsm->dev_idx] &&
            !master->devices[fsm->dev_idx].link_state) {
        ec_device_index_t dev_idx;

        EC_MASTER_DBG(master, 1, "Master state machine detected "
                "link down on %s device. Clearing slave list.\n",
                ec_device_names[fsm->dev_idx != 0]);

        ec_master_slaves_not_available(master);
#ifdef EC_EOE
        ec_master_eoe_stop(master);
        ec_master_clear_eoe_handlers(master, 0);
#endif
        ec_master_clear_slaves(master);
        ec_master_clear_sii_images(master);

        ec_lock_down(&master->config_sem);
        master->config_busy = 0;
        ec_lock_up(&master->config_sem);

        for (dev_idx = EC_DEVICE_MAIN;
                dev_idx < ec_master_num_devices(master); dev_idx++) {
            fsm->slave_states[dev_idx] = 0x00;
            fsm->slaves_responding[dev_idx] = 0; /* Reset to trigger rescan on
                                                    next link up. */
        }
    }
    fsm->link_state[fsm->dev_idx] = master->devices[fsm->dev_idx].link_state;

    if (datagram->state == EC_DATAGRAM_RECEIVED &&
            fsm->slaves_responding[fsm->dev_idx]) {
        uint8_t states = EC_READ_U8(datagram->data);
        if (states != fsm->slave_states[fsm->dev_idx]) {
            // slave states changed
            char state_str[EC_STATE_STRING_SIZE];
            fsm->slave_states[fsm->dev_idx] = states;
            ec_state_string(states, state_str, 1);
            EC_MASTER_INFO(master, "Slave states on %s device: %s.\n",
                    ec_device_names[fsm->dev_idx != 0], state_str);
        }
    } else {
        fsm->slave_states[fsm->dev_idx] = 0x00;
    }

    fsm->dev_idx++;
    if (fsm->dev_idx < ec_master_num_devices(master)) {
        // check number of responding slaves on next device
        fsm->state = ec_fsm_master_state_start;
        fsm->state(fsm); // execute immediately
        return;
    }

    if (fsm->rescan_required) {
        ec_lock_down(&master->scan_sem);
        if (!master->allow_scan) {
            ec_lock_up(&master->scan_sem);
        } else {
            unsigned int count = 0, next_dev_slave, ring_position;
            ec_device_index_t dev_idx;

            master->scan_busy = 1;
            ec_lock_up(&master->scan_sem);

            // clear all slaves and scan the bus
            fsm->rescan_required = 0;
            fsm->idle = 0;
            fsm->scan_jiffies = jiffies;

            ec_master_slaves_not_available(master);
#ifdef EC_EOE
            ec_master_eoe_stop(master);
            ec_master_clear_eoe_handlers(master, 0);
#endif
            ec_master_clear_slaves(master);
            ec_master_clear_sii_images(master);

            ec_lock_down(&master->config_sem);
            master->config_busy = 0;
            ec_lock_up(&master->config_sem);

            for (dev_idx = EC_DEVICE_MAIN;
                    dev_idx < ec_master_num_devices(master); dev_idx++) {
                count += fsm->slaves_responding[dev_idx];
            }

            if (!count) {
                // no slaves present -> finish state machine.
                master->scan_busy = 0;
                wake_up_interruptible(&master->scan_queue);
                ec_fsm_master_restart(fsm);
                return;
            }

            size = sizeof(ec_slave_t) * count;
            if (!(master->slaves =
                        (ec_slave_t *) kmalloc(size, GFP_KERNEL))) {
                EC_MASTER_ERR(master, "Failed to allocate %u bytes"
                        " of slave memory!\n", size);
                master->scan_busy = 0;
                wake_up_interruptible(&master->scan_queue);
                ec_fsm_master_restart(fsm);
                return;
            }

            // init slaves
            dev_idx = EC_DEVICE_MAIN;
            next_dev_slave = fsm->slaves_responding[dev_idx];
            ring_position = 0;
            for (i = 0; i < count; i++, ring_position++) {
                slave = master->slaves + i;
                while (i >= next_dev_slave) {
                    dev_idx++;
                    next_dev_slave += fsm->slaves_responding[dev_idx];
                    ring_position = 0;
                }

                ec_slave_init(slave, master, dev_idx, ring_position, i + 1);

                // do not force reconfiguration in operation phase to avoid
                // unnecesssary process data interruptions
                if (master->phase != EC_OPERATION) {
                    slave->force_config = 1;
                }
            }
            master->slave_count = count;
            master->fsm_slave = master->slaves;

            ec_master_slaves_available(master);
            ec_fsm_master_enter_dc_read_old_times(fsm);
            return;
        }
    }

    if (master->slave_count) {

        // application applied configurations
        if (master->config_changed) {
            master->config_changed = 0;
            master->dc_offset_valid = 0;

            EC_MASTER_DBG(master, 1, "Configuration changed.\n");

            fsm->slave = master->slaves; // begin with first slave
            ec_fsm_master_enter_write_system_times(fsm);

        } else {
            // fetch state from first slave
            fsm->slave = master->slaves;
            ec_datagram_fprd(fsm->datagram, fsm->slave->station_address,
                    0x0130, 2);
            ec_datagram_zero(datagram);
            fsm->datagram->device_index = fsm->slave->device_index;
            fsm->retries = EC_FSM_RETRIES;
            fsm->state = ec_fsm_master_state_read_al_status;
        }
    } else {
        ec_fsm_master_restart(fsm);
    }
}

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

int ec_fsm_master_action_process_sii(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;
    ec_sii_write_request_t *request;

    // search the first request to be processed
    while (1) {
        if (list_empty(&master->sii_requests))
            break;

        // get first request
        request = list_entry(master->sii_requests.next,
                ec_sii_write_request_t, list);
        list_del_init(&request->list); // dequeue
        request->state = EC_INT_REQUEST_BUSY;

        // found pending SII write operation. execute it!
        EC_SLAVE_DBG(request->slave, 1, "Writing SII data...\n");
        fsm->sii_request = request;
        fsm->sii_index = 0;
        ec_fsm_sii_write(&fsm->fsm_sii, request->slave, request->offset,
                request->words, EC_FSM_SII_USE_CONFIGURED_ADDRESS);
        fsm->state = ec_fsm_master_state_write_sii;
        fsm->state(fsm); // execute immediately
        return 1;
    }

    return 0;
}

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

void ec_fsm_master_action_idle(
        ec_fsm_master_t *fsm 
        )
{
    // check for pending SII write operations.
    if (ec_fsm_master_action_process_sii(fsm)) {
        return; // SII write request found
    }

    ec_fsm_master_restart(fsm);
}

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

void ec_fsm_master_action_next_slave_state(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;

    // is there another slave to query?
    fsm->slave++;
    if (fsm->slave < master->slaves + master->slave_count) {
        // fetch state from next slave
        fsm->idle = 1;
        ec_datagram_fprd(fsm->datagram,
                fsm->slave->station_address, 0x0130, 2);
        ec_datagram_zero(fsm->datagram);
        fsm->datagram->device_index = fsm->slave->device_index;
        fsm->retries = EC_FSM_RETRIES;
        fsm->state = ec_fsm_master_state_read_al_status;
        return;
    }

    // all slaves processed
    ec_fsm_master_action_idle(fsm);
}

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

#ifdef EC_LOOP_CONTROL

void ec_fsm_master_action_read_dl_status(
        ec_fsm_master_t *fsm 
        )
{
    ec_datagram_fprd(fsm->datagram, fsm->slave->station_address, 0x0110, 2);
    ec_datagram_zero(fsm->datagram);
    fsm->datagram->device_index = fsm->slave->device_index;
    fsm->retries = EC_FSM_RETRIES;
    fsm->state = ec_fsm_master_state_read_dl_status;
}

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

void ec_fsm_master_action_open_port(
        ec_fsm_master_t *fsm 
        )
{
    EC_SLAVE_INFO(fsm->slave, "Opening ports.\n");

    ec_datagram_fpwr(fsm->datagram, fsm->slave->station_address, 0x0101, 1);
    EC_WRITE_U8(fsm->datagram->data, 0x54); // port 0 auto, 1-3 auto-close
    fsm->datagram->device_index = fsm->slave->device_index;
    fsm->retries = EC_FSM_RETRIES;
    fsm->state = ec_fsm_master_state_open_port;
}

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

void ec_fsm_master_state_read_dl_status(
        ec_fsm_master_t *fsm 
        )
{
    ec_slave_t *slave = fsm->slave;
    ec_datagram_t *datagram = fsm->datagram;
    unsigned int i;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
        return;
    }

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_SLAVE_ERR(slave, "Failed to receive AL state datagram: ");
        ec_datagram_print_state(datagram);
        ec_fsm_master_restart(fsm);
        return;
    }

    // did the slave not respond to its station address?
    if (datagram->working_counter != 1) {
        // try again next time
        ec_fsm_master_action_next_slave_state(fsm);
        return;
    }

    ec_slave_set_dl_status(slave, EC_READ_U16(datagram->data));

    // process port state machines
    for (i = 0; i < EC_MAX_PORTS; i++) {
        ec_slave_port_t *port = &slave->ports[i];

        switch (port->state) {
            case EC_SLAVE_PORT_DOWN:
                if (port->link.loop_closed) {
                    if (port->link.link_up) {
                        port->link_detection_jiffies = jiffies;
                        port->state = EC_SLAVE_PORT_WAIT;
                    }
                }
                else { // loop open
                    port->state = EC_SLAVE_PORT_UP;
                }
                break;
            case EC_SLAVE_PORT_WAIT:
                if (port->link.link_up) {
                    if (jiffies - port->link_detection_jiffies >
                            HZ * EC_PORT_WAIT_MS / 1000) {
                        port->state = EC_SLAVE_PORT_UP;
                        ec_fsm_master_action_open_port(fsm);
                        return;
                    }
                }
                else { // link down
                    port->state = EC_SLAVE_PORT_DOWN;
                }
                break;
            default: // EC_SLAVE_PORT_UP
                if (!port->link.link_up) {
                    port->state = EC_SLAVE_PORT_DOWN;
                }
                break;
        }
    }

    // process next slave
    ec_fsm_master_action_next_slave_state(fsm);
}

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

void ec_fsm_master_state_open_port(
        ec_fsm_master_t *fsm 
        )
{
    ec_slave_t *slave = fsm->slave;
    ec_datagram_t *datagram = fsm->datagram;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
        return;
    }

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_SLAVE_ERR(slave, "Failed to receive port open datagram: ");
        ec_datagram_print_state(datagram);
        ec_fsm_master_restart(fsm);
        return;
    }

    // did the slave not respond to its station address?
    if (datagram->working_counter != 1) {
        EC_SLAVE_ERR(slave, "Did not respond to port open command!\n");
        return;
    }

    // process next slave
    ec_fsm_master_action_next_slave_state(fsm);
}

#endif

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

void ec_fsm_master_action_configure(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;

    if (master->config_changed) {
        master->config_changed = 0;
        master->dc_offset_valid = 0;

        // abort iterating through slaves,
        // first compensate DC system time offsets,
        // then begin configuring at slave 0
        EC_MASTER_DBG(master, 1, "Configuration changed"
                " (aborting state check).\n");

        fsm->slave = master->slaves; // begin with first slave
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    // allow slave to start config (if not already done).
    ec_fsm_slave_set_ready(&fsm->slave->fsm);

#ifdef EC_LOOP_CONTROL
    // read DL status
    ec_fsm_master_action_read_dl_status(fsm);
#else
    // process next slave
    ec_fsm_master_action_next_slave_state(fsm);
#endif
}

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

void ec_fsm_master_state_read_al_status(
        ec_fsm_master_t *fsm 
        )
{
    ec_slave_t *slave = fsm->slave;
    ec_datagram_t *datagram = fsm->datagram;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
        return;
    }

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_SLAVE_ERR(slave, "Failed to receive AL state datagram: ");
        ec_datagram_print_state(datagram);
        ec_fsm_master_restart(fsm);
        return;
    }

    // did the slave not respond to its station address?
    if (datagram->working_counter != 1) {
        if (!slave->error_flag) {
            slave->error_flag = 1;
            EC_SLAVE_DBG(slave, 1, "Slave did not respond to state query.\n");
        }
        fsm->rescan_required = 1;
        ec_fsm_master_restart(fsm);
        return;
    }

    // A single slave responded
    ec_slave_set_al_status(slave, EC_READ_U8(datagram->data));

    if (slave->reboot) {
        // A reboot of this slave was requested
        slave->reboot = 0;
        fsm->idle = 0;
        fsm->state = ec_fsm_master_state_reboot_slave;
        ec_fsm_reboot_single(&fsm->fsm_reboot, slave);
        fsm->state(fsm); // execute immediately
        return;
    }

    if (!slave->error_flag) {
        // Check for configuration
        ec_fsm_master_action_configure(fsm);
        return;
    }

#ifdef EC_LOOP_CONTROL
    // read DL status
    ec_fsm_master_action_read_dl_status(fsm);
#else
    // process next slave
    ec_fsm_master_action_next_slave_state(fsm);
#endif
}

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

void ec_fsm_master_state_reboot_slave(
        ec_fsm_master_t *fsm 
        )
{
    ec_slave_t *slave = fsm->slave;

    if (ec_fsm_reboot_exec(&fsm->fsm_reboot)) {
        return;
    }

    if (!ec_fsm_reboot_success(&fsm->fsm_reboot)) {
        if (slave) {
            EC_SLAVE_ERR(slave, "Failed to reboot.\n");
        } else {
            EC_MASTER_ERR(fsm->master, "Failed to reboot.\n");
        }
    }

    ec_fsm_master_restart(fsm);
}

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

void ec_fsm_master_enter_dc_read_old_times(
        ec_fsm_master_t *fsm 
        )
{
    EC_MASTER_DBG(fsm->master, 1, "Reading old port receive times...\n");

    // read DC port receive times
    // (station addresses not assigned yet, so must APRD.)
    fsm->slave = fsm->master->slaves;
    ec_datagram_aprd(fsm->datagram, fsm->slave->ring_position, 0x0900, 16);
    ec_datagram_zero(fsm->datagram);
    fsm->datagram->device_index = fsm->slave->device_index;
    fsm->retries = EC_FSM_RETRIES;
    fsm->state = ec_fsm_master_state_dc_read_old_times;
}

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

void ec_fsm_master_state_dc_read_old_times(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;
    ec_slave_t *slave = fsm->slave;
    ec_datagram_t *datagram = fsm->datagram;
    int i;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
        return;

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_SLAVE_ERR(slave, "Failed to receive DC receive times datagram: ");
        ec_datagram_print_state(datagram);
        // continue even on error
    } else if (datagram->working_counter != 1) {
        EC_SLAVE_WARN(slave, "Failed to get DC receive times: ");
        ec_datagram_print_wc_error(datagram);
        // continue; this is just a warning because at this point we
        // don't know if the slave supports these registers or not
    }

    for (i = 0; i < EC_MAX_PORTS; i++) {
        slave->ports[i].receive_time = EC_READ_U32(datagram->data + 4 * i);
    }

    ++fsm->slave;
    if (fsm->slave < master->slaves + master->slave_count) {
        // read DC port receive times
        ec_datagram_aprd(datagram, fsm->slave->ring_position, 0x0900, 16);
        ec_datagram_zero(datagram);
        datagram->device_index = fsm->slave->device_index;
        fsm->retries = EC_FSM_RETRIES;
    } else {
        /* start with first device with slaves responding; at least one
         * has responding slaves, otherwise count would be zero. */
        fsm->dev_idx = EC_DEVICE_MAIN;
        while (!fsm->slaves_responding[fsm->dev_idx]) {
            fsm->dev_idx++;
        }

        fsm->slave = master->slaves;
        ec_fsm_master_enter_clear_addresses(fsm);
    }
}

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

void ec_fsm_master_enter_clear_addresses(
        ec_fsm_master_t *fsm 
        )
{
    // broadcast clear all station addresses
    ec_datagram_bwr(fsm->datagram, 0x0010, 2);
    EC_WRITE_U16(fsm->datagram->data, 0x0000);
    fsm->datagram->device_index = fsm->dev_idx;
    fsm->retries = EC_FSM_RETRIES;
    fsm->state = ec_fsm_master_state_clear_addresses;
}

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

void ec_fsm_master_enter_dc_measure_delays(
        ec_fsm_master_t *fsm 
        )
{
    EC_MASTER_DBG(fsm->master, 1, "Sending broadcast-write"
            " to measure transmission delays on %s link.\n",
            ec_device_names[fsm->dev_idx != 0]);

    ec_datagram_bwr(fsm->datagram, 0x0900, 1);
    ec_datagram_zero(fsm->datagram);
    fsm->datagram->device_index = fsm->dev_idx;
    fsm->retries = EC_FSM_RETRIES;
    fsm->state = ec_fsm_master_state_dc_measure_delays;
}

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

#ifdef EC_LOOP_CONTROL

void ec_fsm_master_enter_loop_control(
        ec_fsm_master_t *fsm 
        )
{
    EC_MASTER_DBG(fsm->master, 1, "Broadcast-writing"
            " loop control registers on %s link.\n",
            ec_device_names[fsm->dev_idx != 0]);

    ec_datagram_bwr(fsm->datagram, 0x0101, 1);
    EC_WRITE_U8(fsm->datagram->data, 0x54); // port 0 auto, 1-3 auto-close
    fsm->datagram->device_index = fsm->dev_idx;
    fsm->retries = EC_FSM_RETRIES;
    fsm->state = ec_fsm_master_state_loop_control;
}

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

void ec_fsm_master_state_loop_control(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;
    ec_datagram_t *datagram = fsm->datagram;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
        return;
    }

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_MASTER_ERR(master, "Failed to receive loop control"
                " datagram on %s link: ",
                ec_device_names[fsm->dev_idx != 0]);
        ec_datagram_print_state(datagram);
    }

    ec_fsm_master_enter_dc_measure_delays(fsm);
}

#endif

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

void ec_fsm_master_state_clear_addresses(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;
    ec_datagram_t *datagram = fsm->datagram;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
        return;
    }

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_MASTER_ERR(master, "Failed to receive address"
                " clearing datagram on %s link: ",
                ec_device_names[fsm->dev_idx != 0]);
        ec_datagram_print_state(datagram);
        master->scan_busy = 0;
        wake_up_interruptible(&master->scan_queue);
        ec_fsm_master_restart(fsm);
        return;
    }

    if (datagram->working_counter != fsm->slaves_responding[fsm->dev_idx]) {
        EC_MASTER_WARN(master, "Failed to clear station addresses on %s link:"
                " Cleared %u of %u",
                ec_device_names[fsm->dev_idx != 0], datagram->working_counter,
                fsm->slaves_responding[fsm->dev_idx]);
    }

#ifdef EC_LOOP_CONTROL
    ec_fsm_master_enter_loop_control(fsm);
#else
    ec_fsm_master_enter_dc_measure_delays(fsm);
#endif
}

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

void ec_fsm_master_state_dc_measure_delays(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;
    ec_datagram_t *datagram = fsm->datagram;
    ec_slave_t *slave;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--) {
        return;
    }

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_MASTER_ERR(master, "Failed to receive delay measuring datagram"
                " on %s link: ", ec_device_names[fsm->dev_idx != 0]);
        ec_datagram_print_state(datagram);
        master->scan_busy = 0;
        wake_up_interruptible(&master->scan_queue);
        ec_fsm_master_restart(fsm);
        return;
    }

    EC_MASTER_DBG(master, 1, "%u slaves responded to delay measuring"
            " on %s link.\n",
            datagram->working_counter, ec_device_names[fsm->dev_idx != 0]);

    do {
        fsm->dev_idx++;
    } while (fsm->dev_idx < ec_master_num_devices(master) &&
            !fsm->slaves_responding[fsm->dev_idx]);
    if (fsm->dev_idx < ec_master_num_devices(master)) {
        ec_fsm_master_enter_clear_addresses(fsm);
        return;
    }

    EC_MASTER_INFO(master, "Scanning bus.\n");

    // set slaves ready for requests (begins scan).
    for (slave = master->slaves;
            slave < master->slaves + master->slave_count;
            slave++) {
        ec_fsm_slave_set_ready(&slave->fsm);
    }

    fsm->state = ec_fsm_master_state_scan_slave;
    fsm->datagram->state = EC_DATAGRAM_INVALID; // nothing to send
    fsm->state(fsm);    // execute immediately
}

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

void ec_fsm_master_state_scan_slave(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;
    ec_slave_t *slave;

    for (slave = master->slaves;
            slave < master->slaves + master->slave_count;
            slave++) {
        if (slave->scan_required && !slave->error_flag) {
            // still in progress
            return;
        }
    }

    EC_MASTER_INFO(master, "Bus scanning completed in %lu ms.\n",
            (jiffies - fsm->scan_jiffies) * 1000 / HZ);

    master->scan_busy = 0;
    wake_up_interruptible(&master->scan_queue);

    // Attach slave configurations
    ec_master_attach_slave_configs(master);

    // Set DC ref slave and calc topology and transmission delays
    // Note: must come after attach_slave_configs for application
    //       selected dc_ref_config to return its slave
    ec_master_calc_dc(master);

#ifdef EC_EOE
    // check if EoE processing has to be started
    ec_master_eoe_start(master);
#endif

    if (master->slave_count) {
        master->config_changed = 0;
        master->dc_offset_valid = 0;

        fsm->slave = master->slaves; // begin with first slave
        ec_fsm_master_enter_write_system_times(fsm);
    } else {
        ec_fsm_master_restart(fsm);
    }
}

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

void ec_fsm_master_enter_write_system_times(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;

    if (master->active) {

        while (fsm->slave < master->slaves + master->slave_count) {
            if (!fsm->slave->base_dc_supported
                    || !fsm->slave->has_dc_system_time) {
                fsm->slave++;
                continue;
            }

            EC_SLAVE_DBG(fsm->slave, 1, "Checking system time offset.\n");

            // read DC system time (0x0910, 64 bit)
            //                         gap (64 bit)
            //     and time offset (0x0920, 64 bit)
            //   and receive delay (0x0928, 32 bit)
            ec_datagram_fprd(fsm->datagram, fsm->slave->station_address,
                    0x0910, 28);
            ec_datagram_zero(fsm->datagram);
            fsm->datagram->device_index = fsm->slave->device_index;
            fsm->retries = EC_FSM_RETRIES;
            fsm->state = ec_fsm_master_state_dc_read_offset;
            return;
        }
        master->dc_offset_valid = 1;

    } else {
        EC_MASTER_DBG(master, 1, "No app_time received up to now.\n");
    }

    // scanning and setting system times complete
    ec_master_request_op(master);
    ec_fsm_master_restart(fsm);
}

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

u64 ec_fsm_master_dc_offset32(
        ec_fsm_master_t *fsm, 
        u64 system_time, 
        u64 old_offset, 
        u64 app_time_sent 
        )
{
    ec_slave_t *slave = fsm->slave;
    u32 system_time32, old_offset32, new_offset;
    s32 time_diff;

    system_time32 = (u32) system_time;
    old_offset32 = (u32) old_offset;

    time_diff = (u32) app_time_sent - system_time32;

    EC_SLAVE_DBG(slave, 1, "DC 32 bit system time offset calculation:"
            " system_time=%u, app_time=%llu, diff=%i\n",
            system_time32, app_time_sent, time_diff);

    if (EC_ABS(time_diff) > EC_SYSTEM_TIME_TOLERANCE_NS) {
        new_offset = time_diff + old_offset32;
        EC_SLAVE_DBG(slave, 1, "Setting time offset to %u (was %u)\n",
                new_offset, old_offset32);
        return (u64) new_offset;
    } else {
        EC_SLAVE_DBG(slave, 1, "Not touching time offset.\n");
        return old_offset;
    }
}

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

u64 ec_fsm_master_dc_offset64(
        ec_fsm_master_t *fsm, 
        u64 system_time, 
        u64 old_offset, 
        u64 app_time_sent 
        )
{
    ec_slave_t *slave = fsm->slave;
    u64 new_offset;
    s64 time_diff;

    time_diff = app_time_sent - system_time;

    EC_SLAVE_DBG(slave, 1, "DC 64 bit system time offset calculation:"
            " system_time=%llu, app_time=%llu, diff=%lli\n",
            system_time, app_time_sent, time_diff);

    if (EC_ABS(time_diff) > EC_SYSTEM_TIME_TOLERANCE_NS) {
        new_offset = time_diff + old_offset;
        EC_SLAVE_DBG(slave, 1, "Setting time offset to %llu (was %llu)\n",
                new_offset, old_offset);
    } else {
        new_offset = old_offset;
        EC_SLAVE_DBG(slave, 1, "Not touching time offset.\n");
    }

    return new_offset;
}

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

void ec_fsm_master_state_dc_read_offset(
        ec_fsm_master_t *fsm 
        )
{
    ec_datagram_t *datagram = fsm->datagram;
    ec_slave_t *slave = fsm->slave;
    ec_master_t *master = fsm->master;
    u64 system_time, old_offset, new_offset;
    u32 old_delay;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
        return;

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_SLAVE_ERR(slave, "Failed to receive DC times datagram: ");
        ec_datagram_print_state(datagram);
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    if (datagram->working_counter != 1) {
        EC_SLAVE_WARN(slave, "Failed to get DC times: ");
        ec_datagram_print_wc_error(datagram);
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    if (unlikely(!master->dc_ref_time)) {
        EC_MASTER_WARN(master, "No app_time received up to now,"
                    " abort DC time offset calculation.\n");
        // scanning and setting system times complete
        ec_master_request_op(master);
        ec_fsm_master_restart(fsm);
        return;
    }

    system_time = EC_READ_U64(datagram->data);     // 0x0910
    old_offset = EC_READ_U64(datagram->data + 16); // 0x0920
    old_delay = EC_READ_U32(datagram->data + 24);  // 0x0928

    if (slave->base_dc_range == EC_DC_32) {
        new_offset = ec_fsm_master_dc_offset32(fsm,
                system_time, old_offset, datagram->app_time_sent);
    } else {
        new_offset = ec_fsm_master_dc_offset64(fsm,
                system_time, old_offset, datagram->app_time_sent);
    }

    if (new_offset != old_offset
            && slave->current_state >= EC_SLAVE_STATE_SAFEOP) {
        // Slave is already active; changing the system time offset could
        // cause problems.  Leave the offset alone in this case and just
        // let the normal cyclic sync process gradually adjust it to the
        // correct time.
        EC_SLAVE_DBG(slave, 1, "Slave is running; ignoring DC offset change.\n");
        new_offset = old_offset;
    }

    if (new_offset == old_offset && slave->transmission_delay == old_delay) {
        // offsets have not changed; skip write to avoid possible trouble
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    // set DC system time offset and transmission delay
    ec_datagram_fpwr(datagram, slave->station_address, 0x0920, 12);
    EC_WRITE_U64(datagram->data, new_offset);
    EC_WRITE_U32(datagram->data + 8, slave->transmission_delay);
    fsm->datagram->device_index = slave->device_index;
    fsm->retries = EC_FSM_RETRIES;
    fsm->state = ec_fsm_master_state_dc_write_offset;
}

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

void ec_fsm_master_state_dc_write_offset(
        ec_fsm_master_t *fsm 
        )
{
    ec_datagram_t *datagram = fsm->datagram;
    ec_slave_t *slave = fsm->slave;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
        return;

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_SLAVE_ERR(slave,
                "Failed to receive DC system time offset datagram: ");
        ec_datagram_print_state(datagram);
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    if (datagram->working_counter != 1) {
        EC_SLAVE_ERR(slave, "Failed to set DC system time offset: ");
        ec_datagram_print_wc_error(datagram);
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    // reset DC filter after changing offsets
    if (slave->current_state >= EC_SLAVE_STATE_SAFEOP) {
        EC_SLAVE_DBG(slave, 1, "Slave is running; not resetting DC filter.\n");
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
    } else {
        ec_datagram_fpwr(datagram, slave->station_address, 0x0930, 2);
        EC_WRITE_U16(datagram->data, 0x1000);
        fsm->datagram->device_index = slave->device_index;
        fsm->retries = EC_FSM_RETRIES;
        fsm->state = ec_fsm_master_state_dc_reset_filter;
    }
}

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

void ec_fsm_master_state_dc_reset_filter(
        ec_fsm_master_t *fsm 
        )
{
    ec_datagram_t *datagram = fsm->datagram;
    ec_slave_t *slave = fsm->slave;

    if (datagram->state == EC_DATAGRAM_TIMED_OUT && fsm->retries--)
        return;

    if (datagram->state != EC_DATAGRAM_RECEIVED) {
        EC_SLAVE_ERR(slave,
                "Failed to receive DC reset filter datagram: ");
        ec_datagram_print_state(datagram);
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    if (datagram->working_counter != 1) {
        EC_SLAVE_ERR(slave, "Failed to reset DC filter: ");
        ec_datagram_print_wc_error(datagram);
        fsm->slave++;
        ec_fsm_master_enter_write_system_times(fsm);
        return;
    }

    fsm->slave++;
    ec_fsm_master_enter_write_system_times(fsm);
}

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

void ec_fsm_master_state_write_sii(
        ec_fsm_master_t *fsm 
        )
{
    ec_master_t *master = fsm->master;
    ec_sii_write_request_t *request = fsm->sii_request;
    ec_slave_t *slave = request->slave;

    if (ec_fsm_sii_exec(&fsm->fsm_sii, fsm->datagram)) return;

    if (!ec_fsm_sii_success(&fsm->fsm_sii)) {
        EC_SLAVE_ERR(slave, "Failed to write SII data.\n");
        request->state = EC_INT_REQUEST_FAILURE;
        wake_up_all(&master->request_queue);
        ec_fsm_master_restart(fsm);
        return;
    }

    fsm->sii_index++;
    if (fsm->sii_index < request->nwords) {
        ec_fsm_sii_write(&fsm->fsm_sii, slave,
                request->offset + fsm->sii_index,
                request->words + fsm->sii_index,
                EC_FSM_SII_USE_CONFIGURED_ADDRESS);
        ec_fsm_sii_exec(&fsm->fsm_sii, fsm->datagram); // execute immediately
        return;
    }

    // finished writing SII
    EC_SLAVE_DBG(slave, 1, "Finished writing %zu words of SII data.\n",
            request->nwords);

    if (request->offset <= 4 && request->offset + request->nwords > 4) {
        // alias was written
        if (slave->sii_image) {
            slave->sii_image->sii.alias = EC_READ_U16(request->words + 4);
            // TODO: read alias from register 0x0012
            slave->effective_alias = slave->sii_image->sii.alias;
        }
        else {
            EC_SLAVE_WARN(slave, "Slave could not update effective alias."
                    " SII data not available.\n");
        }
    }
    // TODO: Evaluate other SII contents!

    request->state = EC_INT_REQUEST_SUCCESS;
    wake_up_all(&master->request_queue);

    // check for another SII write request
    if (ec_fsm_master_action_process_sii(fsm))
        return; // processing another request

    ec_fsm_master_restart(fsm);
}

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