--- a/TODO	Thu Aug 03 12:59:01 2006 +0000
+++ b/TODO	Wed Aug 09 14:38:44 2006 +0000
@@ -8,6 +8,12 @@
 
 Important things to do:
 
+* Add Kobjects in constructors.
+
+* Read AL Status Code with AL Control Response.
+
+* Coupling of EoE handlers before configuring slaves.
+
 * SysFS interface
   - Add secondary slave address
   - Add SDO dictionary

--- a/examples/mini/mini.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/examples/mini/mini.c	Wed Aug 09 14:38:44 2006 +0000
@@ -64,6 +64,7 @@
 
 ec_pdo_reg_t domain1_pdos[] = {
     {"1", Beckhoff_EL4132_Output1, &r_ana_out},
+    {"8", Beckhoff_EL5001_Value, NULL},
     {}
 };
 
@@ -123,6 +124,8 @@
 
 int __init init_mini_module(void)
 {
+    ec_slave_t *slave;
+
     printk(KERN_INFO "=== Starting Minimal EtherCAT environment... ===\n");
 
     if ((master = ecrt_request_master(0)) == NULL) {
@@ -145,6 +148,12 @@
         goto out_release_master;
     }
 
+    if (!(slave = ecrt_master_get_slave(master, "8")))
+        goto out_release_master;
+
+    if (ecrt_slave_conf_sdo8(slave, 0x4061, 1, 0))
+        goto out_release_master;
+
     printk(KERN_INFO "Activating master...\n");
     if (ecrt_master_activate(master)) {
         printk(KERN_ERR "Failed to activate master!\n");

--- a/examples/rtai/rtai_sample.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/examples/rtai/rtai_sample.c	Wed Aug 09 14:38:44 2006 +0000
@@ -54,6 +54,8 @@
 
 // RTAI task frequency in Hz
 #define FREQUENCY 10000
+#define INHIBIT_TIME 20
+
 #define TIMERTICKS (1000000000 / FREQUENCY)
 
 /*****************************************************************************/
@@ -61,7 +63,7 @@
 // RTAI
 RT_TASK task;
 SEM master_sem;
-cycles_t t_last_start = 0, t_critical;
+cycles_t t_last_cycle = 0, t_critical;
 
 // EtherCAT
 ec_master_t *master = NULL;
@@ -84,7 +86,7 @@
 {
     while (1)
     {
-        t_last_start = get_cycles();
+        t_last_cycle = get_cycles();
         rt_sem_wait(&master_sem);
 
         ecrt_master_receive(master);
@@ -106,7 +108,7 @@
 int request_lock(void *data)
 {
     // too close to the next RT cycle: deny access...
-    if (get_cycles() - t_last_start > t_critical) return -1;
+    if (get_cycles() - t_last_cycle > t_critical) return -1;
 
     // allow access
     rt_sem_wait(&master_sem);
@@ -130,13 +132,14 @@
 
     rt_sem_init(&master_sem, 1);
 
-    t_critical = cpu_khz * 800 / FREQUENCY; // ticks for 80%
-
-    if ((master = ecrt_request_master(0)) == NULL) {
+    t_critical = cpu_khz * 1000 / FREQUENCY - cpu_khz * INHIBIT_TIME / 1000;
+
+    if (!(master = ecrt_request_master(0))) {
         printk(KERN_ERR "Requesting master 0 failed!\n");
         goto out_return;
     }
 
+
     ecrt_master_callbacks(master, request_lock, release_lock, NULL);
 
     printk(KERN_INFO "Registering domain...\n");

--- a/include/ecdb.h	Thu Aug 03 12:59:01 2006 +0000
+++ b/include/ecdb.h	Wed Aug 09 14:38:44 2006 +0000
@@ -46,6 +46,9 @@
 #define Beckhoff_EL4132_Output1 0x00000002, 0x10243052, 0x6411, 1
 #define Beckhoff_EL4132_Output2 0x00000002, 0x10243052, 0x6411, 2
 
+#define Beckhoff_EL5001_Status 0x00000002, 0x13893052, 0x3101, 1
+#define Beckhoff_EL5001_Value  0x00000002, 0x13893052, 0x3101, 2
+
 /*****************************************************************************/
 
 #endif

--- a/master/device.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/device.c	Wed Aug 09 14:38:44 2006 +0000
@@ -245,7 +245,9 @@
 
     ec_debug_send(&device->dbg, data, size);
 
-    ec_master_receive(device->master, data + ETH_HLEN, size - ETH_HLEN);
+    ec_master_receive_datagrams(device->master,
+                                data + ETH_HLEN,
+                                size - ETH_HLEN);
 }
 
 /*****************************************************************************/

--- a/master/domain.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/domain.c	Wed Aug 09 14:38:44 2006 +0000
@@ -106,6 +106,8 @@
     domain->data_size = 0;
     domain->base_address = 0;
     domain->response_count = 0xFFFFFFFF;
+    domain->t_last = 0;
+    domain->working_counter_changes = 0;
 
     INIT_LIST_HEAD(&domain->data_regs);
     INIT_LIST_HEAD(&domain->datagrams);
@@ -151,7 +153,7 @@
 /*****************************************************************************/
 
 /**
-   Registeres a data field in a domain.
+   Registeres a PDO entry.
    \return 0 in case of success, else < 0
 */
 
@@ -225,7 +227,7 @@
 /*****************************************************************************/
 
 /**
-   Clears the list of the registered data fields.
+   Clears the list of the data registrations.
 */
 
 void ec_domain_clear_data_regs(ec_domain_t *domain /**< EtherCAT domain */)
@@ -511,6 +513,7 @@
 {
     unsigned int working_counter_sum;
     ec_datagram_t *datagram;
+    cycles_t t_now = get_cycles();
 
     working_counter_sum = 0;
     list_for_each_entry(datagram, &domain->datagrams, list) {
@@ -520,9 +523,23 @@
     }
 
     if (working_counter_sum != domain->response_count) {
+        domain->working_counter_changes++;
         domain->response_count = working_counter_sum;
-        EC_INFO("Domain %i working counter change: %i\n", domain->index,
-                domain->response_count);
+    }
+
+    if (domain->working_counter_changes &&
+        (u32) (t_now - domain->t_last) / cpu_khz > 1000) {
+        domain->t_last = t_now;
+        if (domain->working_counter_changes == 1) {
+            EC_INFO("Domain %i working counter change: %i\n", domain->index,
+                    domain->response_count);
+        }
+        else {
+            EC_INFO("Domain %i: %u WC changes. Current response count: %i\n",
+                    domain->index, domain->working_counter_changes,
+                    domain->response_count);
+        }
+        domain->working_counter_changes = 0;
     }
 
     ec_domain_queue(domain);

--- a/master/domain.h	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/domain.h	Wed Aug 09 14:38:44 2006 +0000
@@ -67,6 +67,9 @@
     uint32_t base_address; /**< logical offset address of the process data */
     unsigned int response_count; /**< number of responding slaves */
     struct list_head data_regs; /**< PDO data registrations */
+    unsigned int working_counter_changes; /**< working counter changes
+                                             since last notification */
+    cycles_t t_last; /**< time of last notification */
 };
 
 /*****************************************************************************/

--- a/master/ethernet.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/ethernet.c	Wed Aug 09 14:38:44 2006 +0000
@@ -101,6 +101,12 @@
     eoe->tx_frame_number = 0xFF;
     memset(&eoe->stats, 0, sizeof(struct net_device_stats));
 
+    eoe->rx_counter = 0;
+    eoe->tx_counter = 0;
+    eoe->rx_rate = 0;
+    eoe->tx_rate = 0;
+    eoe->t_last = 0;
+
     if (!(eoe->dev =
           alloc_netdev(sizeof(ec_eoe_t *), "eoe%d", ether_setup))) {
         EC_ERR("Unable to allocate net_device for EoE handler!\n");
@@ -237,7 +243,7 @@
 #if EOE_DEBUG_LEVEL > 1
     EC_DBG("");
     for (i = 0; i < current_size; i++) {
-        printk("%02X ", frame->skb->data[eoe->tx_offset + i]);
+        printk("%02X ", eoe->tx_frame->skb->data[eoe->tx_offset + i]);
         if ((i + 1) % 16 == 0) {
             printk("\n");
             EC_DBG("");
@@ -272,10 +278,22 @@
 
 void ec_eoe_run(ec_eoe_t *eoe /**< EoE handler */)
 {
+    cycles_t t_now;
+
     if (!eoe->opened) return;
 
     // call state function
     eoe->state(eoe);
+
+    // update statistics
+    t_now = get_cycles();
+    if ((u32) (t_now - eoe->t_last) > cpu_khz * 1000) {
+        eoe->rx_rate = eoe->rx_counter * 8;
+        eoe->tx_rate = eoe->tx_counter * 8;
+        eoe->rx_counter = 0;
+        eoe->tx_counter = 0;
+        eoe->t_last = t_now;
+    }
 }
 
 /*****************************************************************************/
@@ -285,7 +303,7 @@
    \return 1 if the device is "up", 0 if it is "down"
 */
 
-unsigned int ec_eoe_active(const ec_eoe_t *eoe /**< EoE handler */)
+int ec_eoe_active(const ec_eoe_t *eoe /**< EoE handler */)
 {
     return eoe->slave && eoe->opened;
 }
@@ -350,6 +368,9 @@
     uint8_t *data, frame_type, last_fragment, time_appended;
     uint8_t frame_number, fragment_offset, fragment_number;
     off_t offset;
+#if EOE_DEBUG_LEVEL > 1
+    unsigned int i;
+#endif
 
     if (eoe->datagram.state != EC_DATAGRAM_RECEIVED) {
         eoe->stats.rx_errors++;
@@ -452,6 +473,7 @@
         // update statistics
         eoe->stats.rx_packets++;
         eoe->stats.rx_bytes += eoe->rx_skb->len;
+        eoe->rx_counter += eoe->rx_skb->len;
 
 #if EOE_DEBUG_LEVEL > 0
         EC_DBG("EoE RX frame completed with %u octets.\n",
@@ -490,7 +512,7 @@
 void ec_eoe_state_tx_start(ec_eoe_t *eoe /**< EoE handler */)
 {
 #if EOE_DEBUG_LEVEL > 0
-    unsigned int wakeup;
+    unsigned int wakeup = 0;
 #endif
 
     if (!eoe->slave->online || !eoe->slave->master->device->link_state)
@@ -568,6 +590,7 @@
     if (eoe->tx_offset >= eoe->tx_frame->skb->len) {
         eoe->stats.tx_packets++;
         eoe->stats.tx_bytes += eoe->tx_frame->skb->len;
+        eoe->tx_counter += eoe->tx_frame->skb->len;
         dev_kfree_skb(eoe->tx_frame->skb);
         kfree(eoe->tx_frame);
         eoe->tx_frame = NULL;

--- a/master/ethernet.h	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/ethernet.h	Wed Aug 09 14:38:44 2006 +0000
@@ -78,10 +78,13 @@
     struct net_device *dev; /**< net_device for virtual ethernet device */
     struct net_device_stats stats; /**< device statistics */
     unsigned int opened; /**< net_device is opened */
+    cycles_t t_last; /**< time of last rate output */
     struct sk_buff *rx_skb; /**< current rx socket buffer */
     off_t rx_skb_offset; /**< current write pointer in the socket buffer */
     size_t rx_skb_size; /**< size of the allocated socket buffer memory */
     uint8_t rx_expected_fragment; /**< next expected fragment number */
+    uint32_t rx_counter; /**< octets received during last second */
+    uint32_t rx_rate; /**< receive rate (bps) */
     struct list_head tx_queue; /**< queue for frames to send */
     unsigned int tx_queue_active; /**< kernel netif queue started */
     unsigned int tx_queued_frames; /**< number of frames in the queue */
@@ -90,6 +93,8 @@
     uint8_t tx_frame_number; /**< number of the transmitted frame */
     uint8_t tx_fragment_number; /**< number of the fragment */
     size_t tx_offset; /**< number of octets sent */
+    uint32_t tx_counter; /**< octets transmitted during last second */
+    uint32_t tx_rate; /**< transmit rate (bps) */
 };
 
 /*****************************************************************************/
@@ -97,6 +102,6 @@
 int ec_eoe_init(ec_eoe_t *);
 void ec_eoe_clear(ec_eoe_t *);
 void ec_eoe_run(ec_eoe_t *);
-unsigned int ec_eoe_active(const ec_eoe_t *);
+int ec_eoe_active(const ec_eoe_t *);
 
 /*****************************************************************************/

--- a/master/fsm.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/fsm.c	Wed Aug 09 14:38:44 2006 +0000
@@ -41,6 +41,7 @@
 #include "globals.h"
 #include "fsm.h"
 #include "master.h"
+#include "mailbox.h"
 
 /*****************************************************************************/
 
@@ -73,6 +74,7 @@
 void ec_fsm_slaveconf_sync(ec_fsm_t *);
 void ec_fsm_slaveconf_preop(ec_fsm_t *);
 void ec_fsm_slaveconf_fmmu(ec_fsm_t *);
+void ec_fsm_slaveconf_sdoconf(ec_fsm_t *);
 void ec_fsm_slaveconf_saveop(ec_fsm_t *);
 void ec_fsm_slaveconf_op(ec_fsm_t *);
 
@@ -90,9 +92,16 @@
 void ec_fsm_change_ack(ec_fsm_t *);
 void ec_fsm_change_check_ack(ec_fsm_t *);
 
+void ec_fsm_coe_down_start(ec_fsm_t *);
+void ec_fsm_coe_down_request(ec_fsm_t *);
+void ec_fsm_coe_down_check(ec_fsm_t *);
+void ec_fsm_coe_down_response(ec_fsm_t *);
+
 void ec_fsm_end(ec_fsm_t *);
 void ec_fsm_error(ec_fsm_t *);
 
+void ec_canopen_abort_msg(uint32_t);
+
 /*****************************************************************************/
 
 /**
@@ -1373,11 +1382,18 @@
         return;
     }
 
-    if (!slave->base_fmmu_count) {
-        fsm->slave_state = ec_fsm_slaveconf_saveop;
-        fsm->change_new = EC_SLAVE_STATE_SAVEOP;
-        fsm->change_state = ec_fsm_change_start;
-        fsm->change_state(fsm); // execute immediately
+    if (!slave->base_fmmu_count) { // skip FMMU configuration
+        if (list_empty(&slave->sdo_confs)) { // skip SDO configuration
+            fsm->slave_state = ec_fsm_slaveconf_saveop;
+            fsm->change_new = EC_SLAVE_STATE_SAVEOP;
+            fsm->change_state = ec_fsm_change_start;
+            fsm->change_state(fsm); // execute immediately
+            return;
+        }
+        fsm->slave_state = ec_fsm_slaveconf_sdoconf;
+        fsm->sdodata = list_entry(slave->sdo_confs.next, ec_sdo_data_t, list);
+        fsm->coe_state = ec_fsm_coe_down_start;
+        fsm->coe_state(fsm); // execute immediately
         return;
     }
 
@@ -1403,6 +1419,7 @@
 void ec_fsm_slaveconf_fmmu(ec_fsm_t *fsm /**< finite state machine */)
 {
     ec_datagram_t *datagram = &fsm->datagram;
+    ec_slave_t *slave = fsm->slave;
 
     if (datagram->state != EC_DATAGRAM_RECEIVED
         || datagram->working_counter != 1) {
@@ -1413,6 +1430,51 @@
         return;
     }
 
+    // No CoE configuration to be applied? Jump to SAVEOP state.
+    if (list_empty(&slave->sdo_confs)) { // skip SDO configuration
+        // set state to SAVEOP
+        fsm->slave_state = ec_fsm_slaveconf_saveop;
+        fsm->change_new = EC_SLAVE_STATE_SAVEOP;
+        fsm->change_state = ec_fsm_change_start;
+        fsm->change_state(fsm); // execute immediately
+        return;
+    }
+
+    fsm->slave_state = ec_fsm_slaveconf_sdoconf;
+    fsm->sdodata = list_entry(slave->sdo_confs.next, ec_sdo_data_t, list);
+    fsm->coe_state = ec_fsm_coe_down_start;
+    fsm->coe_state(fsm); // execute immediately
+}
+
+/*****************************************************************************/
+
+/**
+   Slave state: SDOCONF.
+*/
+
+void ec_fsm_slaveconf_sdoconf(ec_fsm_t *fsm /**< finite state machine */)
+{
+    fsm->coe_state(fsm); // execute CoE state machine
+
+    if (fsm->coe_state == ec_fsm_error) {
+        fsm->slave->error_flag = 1;
+        fsm->slave_state = ec_fsm_error;
+        return;
+    }
+
+    if (fsm->coe_state != ec_fsm_end) return;
+
+    // Another SDO to configure?
+    if (fsm->sdodata->list.next != &fsm->slave->sdo_confs) {
+        fsm->sdodata = list_entry(fsm->sdodata->list.next,
+                                  ec_sdo_data_t, list);
+        fsm->coe_state = ec_fsm_coe_down_start;
+        fsm->coe_state(fsm); // execute immediately
+        return;
+    }
+
+    // All SDOs are now configured.
+
     // set state to SAVEOP
     fsm->slave_state = ec_fsm_slaveconf_saveop;
     fsm->change_new = EC_SLAVE_STATE_SAVEOP;
@@ -1934,7 +1996,244 @@
     ec_master_queue_datagram(fsm->master, datagram);
 }
 
-/*****************************************************************************/
+/******************************************************************************
+ *  CoE state machine
+ *****************************************************************************/
+
+/**
+   CoE state: DOWN_START.
+*/
+
+void ec_fsm_coe_down_start(ec_fsm_t *fsm /**< finite state machine */)
+{
+    ec_datagram_t *datagram = &fsm->datagram;
+    ec_slave_t *slave = fsm->slave;
+    ec_sdo_data_t *sdodata = fsm->sdodata;
+    uint8_t *data;
+
+    EC_INFO("Downloading SDO 0x%04X:%i to slave %i.\n",
+            sdodata->index, sdodata->subindex, slave->ring_position);
+
+    if (slave->sii_rx_mailbox_size < 6 + 10 + sdodata->size) {
+        EC_ERR("SDO fragmenting not supported yet!\n");
+        fsm->coe_state = ec_fsm_error;
+        return;
+    }
+
+    if (!(data = ec_slave_mbox_prepare_send(slave, datagram, 0x03,
+                                            sdodata->size + 10))) {
+        fsm->coe_state = ec_fsm_error;
+        return;
+    }
+
+    EC_WRITE_U16(data, 0x2 << 12); // SDO request
+    EC_WRITE_U8 (data + 2, (0x1 // size specified
+                            | 0x1 << 5)); // Download request
+    EC_WRITE_U16(data + 3, sdodata->index);
+    EC_WRITE_U8 (data + 5, sdodata->subindex);
+    EC_WRITE_U32(data + 6, sdodata->size);
+    memcpy(data + 6, sdodata->data, sdodata->size);
+
+    ec_master_queue_datagram(fsm->master, datagram);
+    fsm->coe_state = ec_fsm_coe_down_request;
+}
+
+/*****************************************************************************/
+
+/**
+   CoE state: DOWN_REQUEST.
+*/
+
+void ec_fsm_coe_down_request(ec_fsm_t *fsm /**< finite state machine */)
+{
+    ec_datagram_t *datagram = &fsm->datagram;
+    ec_slave_t *slave = fsm->slave;
+
+    if (datagram->state != EC_DATAGRAM_RECEIVED
+        || datagram->working_counter != 1) {
+        fsm->coe_state = ec_fsm_error;
+        EC_ERR("Reception of CoE download request failed.\n");
+        return;
+    }
+
+    fsm->coe_start = get_cycles();
+
+    ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
+    ec_master_queue_datagram(fsm->master, datagram);
+    fsm->coe_state = ec_fsm_coe_down_check;
+}
+
+/*****************************************************************************/
+
+/**
+   CoE state: DOWN_CHECK.
+*/
+
+void ec_fsm_coe_down_check(ec_fsm_t *fsm /**< finite state machine */)
+{
+    ec_datagram_t *datagram = &fsm->datagram;
+    ec_slave_t *slave = fsm->slave;
+
+    if (datagram->state != EC_DATAGRAM_RECEIVED
+        || datagram->working_counter != 1) {
+        fsm->coe_state = ec_fsm_error;
+        EC_ERR("Reception of CoE mailbox check datagram failed.\n");
+        return;
+    }
+
+    if (!ec_slave_mbox_check(datagram)) {
+        if (get_cycles() - fsm->coe_start >= (cycles_t) 100 * cpu_khz) {
+            fsm->coe_state = ec_fsm_error;
+            EC_ERR("Timeout while checking SDO configuration on slave %i.\n",
+                   slave->ring_position);
+            return;
+        }
+
+        ec_slave_mbox_prepare_check(slave, datagram); // can not fail.
+        ec_master_queue_datagram(fsm->master, datagram);
+        return;
+    }
+
+    // Fetch response
+    ec_slave_mbox_prepare_fetch(slave, datagram); // can not fail.
+    ec_master_queue_datagram(fsm->master, datagram);
+    fsm->coe_state = ec_fsm_coe_down_response;
+}
+
+/*****************************************************************************/
+
+/**
+   CoE state: DOWN_RESPONSE.
+*/
+
+void ec_fsm_coe_down_response(ec_fsm_t *fsm /**< finite state machine */)
+{
+    ec_datagram_t *datagram = &fsm->datagram;
+    ec_slave_t *slave = fsm->slave;
+    uint8_t *data;
+    size_t rec_size;
+    ec_sdo_data_t *sdodata = fsm->sdodata;
+
+    if (datagram->state != EC_DATAGRAM_RECEIVED
+        || datagram->working_counter != 1) {
+        fsm->coe_state = ec_fsm_error;
+        EC_ERR("Reception of CoE download response failed.\n");
+        return;
+    }
+
+    if (!(data = ec_slave_mbox_fetch(slave, datagram, 0x03, &rec_size))) {
+        fsm->coe_state = ec_fsm_error;
+        return;
+    }
+
+    if (rec_size < 6) {
+        fsm->coe_state = ec_fsm_error;
+        EC_ERR("Received data is too small (%i bytes):\n", rec_size);
+        ec_print_data(data, rec_size);
+        return;
+    }
+
+    if (EC_READ_U16(data) >> 12 == 0x2 && // SDO request
+        EC_READ_U8 (data + 2) >> 5 == 0x4) { // abort SDO transfer request
+        fsm->coe_state = ec_fsm_error;
+        EC_ERR("SDO download 0x%04X:%X (%i bytes) aborted on slave %i.\n",
+               sdodata->index, sdodata->subindex, sdodata->size,
+               slave->ring_position);
+        if (rec_size < 10) {
+            EC_ERR("Incomplete Abort command:\n");
+            ec_print_data(data, rec_size);
+        }
+        else
+            ec_canopen_abort_msg(EC_READ_U32(data + 6));
+        return;
+    }
+
+    if (EC_READ_U16(data) >> 12 != 0x3 || // SDO response
+        EC_READ_U8 (data + 2) >> 5 != 0x3 || // Download response
+        EC_READ_U16(data + 3) != sdodata->index || // index
+        EC_READ_U8 (data + 5) != sdodata->subindex) { // subindex
+        fsm->coe_state = ec_fsm_error;
+        EC_ERR("SDO download 0x%04X:%X (%i bytes) failed:\n",
+               sdodata->index, sdodata->subindex, sdodata->size);
+        EC_ERR("Invalid SDO download response at slave %i!\n",
+               slave->ring_position);
+        ec_print_data(data, rec_size);
+        return;
+    }
+
+    fsm->coe_state = ec_fsm_end; // success
+}
+
+/*****************************************************************************/
+
+/**
+   SDO abort messages.
+   The "abort SDO transfer request" supplies an abort code,
+   which can be translated to clear text. This table does
+   the mapping of the codes and messages.
+*/
+
+const ec_code_msg_t sdo_abort_messages[] = {
+    {0x05030000, "Toggle bit not changed"},
+    {0x05040000, "SDO protocol timeout"},
+    {0x05040001, "Client/Server command specifier not valid or unknown"},
+    {0x05040005, "Out of memory"},
+    {0x06010000, "Unsupported access to an object"},
+    {0x06010001, "Attempt to read a write-only object"},
+    {0x06010002, "Attempt to write a read-only object"},
+    {0x06020000, "This object does not exist in the object directory"},
+    {0x06040041, "The object cannot be mapped into the PDO"},
+    {0x06040042, "The number and length of the objects to be mapped would"
+     " exceed the PDO length"},
+    {0x06040043, "General parameter incompatibility reason"},
+    {0x06040047, "Gerneral internal incompatibility in device"},
+    {0x06060000, "Access failure due to a hardware error"},
+    {0x06070010, "Data type does not match, length of service parameter does"
+     " not match"},
+    {0x06070012, "Data type does not match, length of service parameter too"
+     " high"},
+    {0x06070013, "Data type does not match, length of service parameter too"
+     " low"},
+    {0x06090011, "Subindex does not exist"},
+    {0x06090030, "Value range of parameter exceeded"},
+    {0x06090031, "Value of parameter written too high"},
+    {0x06090032, "Value of parameter written too low"},
+    {0x06090036, "Maximum value is less than minimum value"},
+    {0x08000000, "General error"},
+    {0x08000020, "Data cannot be transferred or stored to the application"},
+    {0x08000021, "Data cannot be transferred or stored to the application"
+     " because of local control"},
+    {0x08000022, "Data cannot be transferred or stored to the application"
+     " because of the present device state"},
+    {0x08000023, "Object dictionary dynamic generation fails or no object"
+     " dictionary is present"},
+    {}
+};
+
+/*****************************************************************************/
+
+/**
+   Outputs an SDO abort message.
+*/
+
+void ec_canopen_abort_msg(uint32_t abort_code)
+{
+    const ec_code_msg_t *abort_msg;
+
+    for (abort_msg = sdo_abort_messages; abort_msg->code; abort_msg++) {
+        if (abort_msg->code == abort_code) {
+            EC_ERR("SDO abort message 0x%08X: \"%s\".\n",
+                   abort_msg->code, abort_msg->message);
+            return;
+        }
+    }
+
+    EC_ERR("Unknown SDO abort code 0x%08X.\n", abort_code);
+}
+
+/******************************************************************************
+ *  Common state functions
+ *****************************************************************************/
 
 /**
    State: ERROR.

--- a/master/fsm.h	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/fsm.h	Wed Aug 09 14:38:44 2006 +0000
@@ -74,8 +74,12 @@
     cycles_t sii_start; /**< sii start */
 
     void (*change_state)(ec_fsm_t *); /**< slave state change state function */
-    uint8_t change_new; /**< input: new state */
+    ec_slave_state_t change_new; /**< input: new state */
     cycles_t change_start; /**< change start */
+
+    void (*coe_state)(ec_fsm_t *); /**< CoE state function */
+    ec_sdo_data_t *sdodata; /**< input/output: SDO data object */
+    cycles_t coe_start; /**< CoE timestamp */
 };
 
 /*****************************************************************************/

--- a/master/mailbox.h	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/mailbox.h	Wed Aug 09 14:38:44 2006 +0000
@@ -53,11 +53,6 @@
 uint8_t *ec_slave_mbox_fetch(const ec_slave_t *, ec_datagram_t *,
                              uint8_t, size_t *);
 
-uint8_t *ec_slave_mbox_simple_io(const ec_slave_t *, ec_datagram_t *,
-                                 size_t *);
-uint8_t *ec_slave_mbox_simple_receive(const ec_slave_t *, ec_datagram_t *,
-                                      uint8_t, size_t *);
-
 /*****************************************************************************/
 
 #endif

--- a/master/master.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/master.c	Wed Aug 09 14:38:44 2006 +0000
@@ -65,14 +65,12 @@
 
 /** \cond */
 
-EC_SYSFS_READ_ATTR(slave_count);
-EC_SYSFS_READ_ATTR(mode);
+EC_SYSFS_READ_ATTR(info);
 EC_SYSFS_READ_WRITE_ATTR(eeprom_write_enable);
 EC_SYSFS_READ_WRITE_ATTR(debug_level);
 
 static struct attribute *ec_def_attrs[] = {
-    &attr_slave_count,
-    &attr_mode,
+    &attr_info,
     &attr_eeprom_write_enable,
     &attr_debug_level,
     NULL,
@@ -121,6 +119,13 @@
     master->eoe_timer.data = (unsigned long) master;
     master->internal_lock = SPIN_LOCK_UNLOCKED;
     master->eoe_running = 0;
+    master->eoe_checked = 0;
+    for (i = 0; i < HZ; i++) {
+        master->idle_cycle_times[i] = 0;
+        master->eoe_cycle_times[i] = 0;
+    }
+    master->idle_cycle_time_pos = 0;
+    master->eoe_cycle_time_pos = 0;
 
     // create workqueue
     if (!(master->workqueue = create_singlethread_workqueue("EtherCAT"))) {
@@ -239,6 +244,7 @@
     master->stats.timeouts = 0;
     master->stats.delayed = 0;
     master->stats.corrupted = 0;
+    master->stats.skipped = 0;
     master->stats.unmatched = 0;
     master->stats.t_last = 0;
 
@@ -286,9 +292,9 @@
     // check, if the datagram is already queued
     list_for_each_entry(queued_datagram, &master->datagram_queue, queue) {
         if (queued_datagram == datagram) {
+            master->stats.skipped++;
+            ec_master_output_stats(master);
             datagram->state = EC_DATAGRAM_QUEUED;
-            if (unlikely(master->debug_level))
-                EC_WARN("datagram already queued.\n");
             return;
         }
     }
@@ -405,10 +411,10 @@
    \return 0 in case of success, else < 0
 */
 
-void ec_master_receive(ec_master_t *master, /**< EtherCAT master */
-                       const uint8_t *frame_data, /**< received data */
-                       size_t size /**< size of the received data */
-                       )
+void ec_master_receive_datagrams(ec_master_t *master, /**< EtherCAT master */
+                                 const uint8_t *frame_data, /**< frame data */
+                                 size_t size /**< size of the received data */
+                                 )
 {
     size_t frame_size, data_size;
     uint8_t datagram_type, datagram_index;
@@ -537,6 +543,10 @@
             EC_WARN("%i frame(s) CORRUPTED!\n", master->stats.corrupted);
             master->stats.corrupted = 0;
         }
+        if (master->stats.skipped) {
+            EC_WARN("%i datagram(s) SKIPPED!\n", master->stats.skipped);
+            master->stats.skipped = 0;
+        }
         if (master->stats.unmatched) {
             EC_WARN("%i datagram(s) UNMATCHED!\n", master->stats.unmatched);
             master->stats.unmatched = 0;
@@ -600,20 +610,28 @@
 void ec_master_idle_run(void *data /**< master pointer */)
 {
     ec_master_t *master = (ec_master_t *) data;
+    cycles_t start, end;
 
     // aquire master lock
     spin_lock_bh(&master->internal_lock);
 
+    start = get_cycles();
     ecrt_master_receive(master);
 
     // execute master state machine
     ec_fsm_execute(&master->fsm);
 
     ecrt_master_send(master);
+    end = get_cycles();
 
     // release master lock
     spin_unlock_bh(&master->internal_lock);
 
+    master->idle_cycle_times[master->idle_cycle_time_pos]
+        = (u32) (end - start) * 1000 / cpu_khz;
+    master->idle_cycle_time_pos++;
+    master->idle_cycle_time_pos %= HZ;
+
     if (master->mode == EC_MASTER_MODE_IDLE)
         queue_delayed_work(master->workqueue, &master->idle_work, 1);
 }
@@ -680,6 +698,78 @@
 /*****************************************************************************/
 
 /**
+   Formats master information for SysFS read access.
+   \return number of bytes written
+*/
+
+ssize_t ec_master_info(ec_master_t *master, /**< EtherCAT master */
+                       char *buffer /**< memory to store data */
+                       )
+{
+    off_t off = 0;
+    ec_eoe_t *eoe;
+    uint32_t cur, sum, min, max, pos, i;
+
+    off += sprintf(buffer + off, "\nMode: ");
+    switch (master->mode) {
+        case EC_MASTER_MODE_ORPHANED:
+            off += sprintf(buffer + off, "ORPHANED");
+            break;
+        case EC_MASTER_MODE_IDLE:
+            off += sprintf(buffer + off, "IDLE");
+            break;
+        case EC_MASTER_MODE_OPERATION:
+            off += sprintf(buffer + off, "OPERATION");
+            break;
+    }
+
+    off += sprintf(buffer + off, "\nSlaves: %i\n",
+                   master->slave_count);
+
+    off += sprintf(buffer + off, "\nTiming (min/avg/max) [us]:\n");
+
+    sum = 0;
+    min = 0xFFFFFFFF;
+    max = 0;
+    pos = master->idle_cycle_time_pos;
+    for (i = 0; i < HZ; i++) {
+        cur = master->idle_cycle_times[(i + pos) % HZ];
+        sum += cur;
+        if (cur < min) min = cur;
+        if (cur > max) max = cur;
+    }
+    off += sprintf(buffer + off, "  Idle cycle: %u / %u.%u / %u\n",
+                   min, sum / HZ, (sum * 100 / HZ) % 100, max);
+
+    sum = 0;
+    min = 0xFFFFFFFF;
+    max = 0;
+    pos = master->eoe_cycle_time_pos;
+    for (i = 0; i < HZ; i++) {
+        cur = master->eoe_cycle_times[(i + pos) % HZ];
+        sum += cur;
+        if (cur < min) min = cur;
+        if (cur > max) max = cur;
+    }
+    off += sprintf(buffer + off, "  EoE cycle: %u / %u.%u / %u\n",
+                   min, sum / HZ, (sum * 100 / HZ) % 100, max);
+
+    if (!list_empty(&master->eoe_handlers))
+        off += sprintf(buffer + off, "\nEoE statistics (RX/TX) [bps]:\n");
+    list_for_each_entry(eoe, &master->eoe_handlers, list) {
+        off += sprintf(buffer + off, "  %s: %u / %u (%u KB/s)\n",
+                       eoe->dev->name, eoe->rx_rate, eoe->tx_rate,
+                       ((eoe->rx_rate + eoe->tx_rate) / 8 + 512) / 1024);
+    }
+
+    off += sprintf(buffer + off, "\n");
+
+    return off;
+}
+
+/*****************************************************************************/
+
+/**
    Formats attribute data for SysFS read access.
    \return number of bytes to read
 */
@@ -691,18 +781,8 @@
 {
     ec_master_t *master = container_of(kobj, ec_master_t, kobj);
 
-    if (attr == &attr_slave_count) {
-        return sprintf(buffer, "%i\n", master->slave_count);
-    }
-    else if (attr == &attr_mode) {
-        switch (master->mode) {
-            case EC_MASTER_MODE_ORPHANED:
-                return sprintf(buffer, "ORPHANED\n");
-            case EC_MASTER_MODE_IDLE:
-                return sprintf(buffer, "IDLE\n");
-            case EC_MASTER_MODE_OPERATION:
-                return sprintf(buffer, "OPERATION\n");
-        }
+    if (attr == &attr_info) {
+        return ec_master_info(master, buffer);
     }
     else if (attr == &attr_debug_level) {
         return sprintf(buffer, "%i\n", master->debug_level);
@@ -773,7 +853,7 @@
 /*****************************************************************************/
 
 /**
-   Starts/Stops Ethernet-over-EtherCAT processing on demand.
+   Starts Ethernet-over-EtherCAT processing on demand.
 */
 
 void ec_master_eoe_start(ec_master_t *master /**< EtherCAT master */)
@@ -782,12 +862,17 @@
     ec_slave_t *slave;
     unsigned int coupled, found;
 
-    if (master->eoe_running) return;
+    if (master->eoe_running || master->eoe_checked) return;
+
+    master->eoe_checked = 1;
 
     // if the locking callbacks are not set in operation mode,
     // the EoE timer my not be started.
     if (master->mode == EC_MASTER_MODE_OPERATION
-        && (!master->request_cb || !master->release_cb)) return;
+        && (!master->request_cb || !master->release_cb)) {
+        EC_INFO("No EoE processing because of missing locking callbacks.\n");
+        return;
+    }
 
     // decouple all EoE handlers
     list_for_each_entry(eoe, &master->eoe_handlers, list)
@@ -843,6 +928,8 @@
 {
     ec_eoe_t *eoe;
 
+    master->eoe_checked = 0;
+
     if (!master->eoe_running) return;
 
     EC_INFO("Stopping EoE processing.\n");
@@ -871,6 +958,7 @@
     ec_master_t *master = (ec_master_t *) data;
     ec_eoe_t *eoe;
     unsigned int active = 0;
+    cycles_t start, end;
 
     list_for_each_entry(eoe, &master->eoe_handlers, list) {
         if (ec_eoe_active(eoe)) active++;
@@ -890,11 +978,15 @@
         goto queue_timer;
 
     // actual EoE stuff
+    start = get_cycles();
     ecrt_master_receive(master);
+
     list_for_each_entry(eoe, &master->eoe_handlers, list) {
         ec_eoe_run(eoe);
     }
+
     ecrt_master_send(master);
+    end = get_cycles();
 
     // release lock...
     if (master->mode == EC_MASTER_MODE_OPERATION) {
@@ -904,6 +996,11 @@
         spin_unlock(&master->internal_lock);
     }
 
+    master->eoe_cycle_times[master->eoe_cycle_time_pos]
+        = (u32) (end - start) * 1000 / cpu_khz;
+    master->eoe_cycle_time_pos++;
+    master->eoe_cycle_time_pos %= HZ;
+
  queue_timer:
     master->eoe_timer.expires += HZ / EC_EOE_FREQUENCY;
     add_timer(&master->eoe_timer);
@@ -941,6 +1038,69 @@
     }
 }
 
+/*****************************************************************************/
+
+/**
+   Measures the time, a frame is on the bus.
+*/
+
+void ec_master_measure_bus_time(ec_master_t *master)
+{
+    ec_datagram_t datagram;
+    cycles_t t_start, t_end, t_timeout;
+    uint32_t times[100], sum, min, max, i;
+
+    ec_datagram_init(&datagram);
+
+    if (ec_datagram_brd(&datagram, 0x130, 2)) {
+        EC_ERR("Failed to allocate datagram for bus time measuring.\n");
+        ec_datagram_clear(&datagram);
+        return;
+    }
+
+    t_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
+
+    sum = 0;
+    min = 0xFFFFFFFF;
+    max = 0;
+
+    for (i = 0; i < 100; i++) {
+        ec_master_queue_datagram(master, &datagram);
+        ecrt_master_send(master);
+        t_start = get_cycles();
+
+        while (1) { // active waiting
+            ec_device_call_isr(master->device);
+            t_end = get_cycles(); // take current time
+
+            if (datagram.state == EC_DATAGRAM_RECEIVED) {
+                break;
+            }
+            else if (datagram.state == EC_DATAGRAM_ERROR) {
+                EC_WARN("Failed to measure bus time.\n");
+                goto error;
+            }
+            else if (t_end - t_start >= t_timeout) {
+                EC_WARN("Timeout while measuring bus time.\n");
+                goto error;
+            }
+        }
+
+        times[i] = (unsigned int) (t_end - t_start) * 1000 / cpu_khz;
+        sum += times[i];
+        if (times[i] > max) max = times[i];
+        if (times[i] < min) min = times[i];
+    }
+
+    EC_INFO("Bus time is (min/avg/max) %u/%u.%u/%u us.\n",
+            min, sum / 100, sum % 100, max);
+
+  error:
+    // Dequeue and free datagram
+    list_del(&datagram.queue);
+    ec_datagram_clear(&datagram);
+}
+
 /******************************************************************************
  *  Realtime interface
  *****************************************************************************/
@@ -1163,7 +1323,7 @@
     ec_device_call_isr(master->device);
 
     t_received = get_cycles();
-    t_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
+    t_timeout = EC_IO_TIMEOUT * cpu_khz / 1000;
 
     // dequeue all received datagrams
     list_for_each_entry_safe(datagram, next, &master->datagram_queue, queue)

--- a/master/master.h	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/master.h	Wed Aug 09 14:38:44 2006 +0000
@@ -74,7 +74,10 @@
     unsigned int timeouts; /**< datagram timeouts */
     unsigned int delayed; /**< delayed datagrams */
     unsigned int corrupted; /**< corrupted frames */
-    unsigned int unmatched; /**< unmatched datagrams */
+    unsigned int skipped; /**< skipped datagrams (the ones that were
+                             requeued when not yet received) */
+    unsigned int unmatched; /**< unmatched datagrams (received, but not
+                               queued any longer) */
     cycles_t t_last; /**< time of last output */
 }
 ec_stats_t;
@@ -94,11 +97,14 @@
 
     struct kobject kobj; /**< kobject */
 
+    ec_device_t *device; /**< EtherCAT device */
+
+    ec_fsm_t fsm; /**< master state machine */
+    ec_master_mode_t mode; /**< master mode */
+
     struct list_head slaves; /**< list of slaves on the bus */
     unsigned int slave_count; /**< number of slaves on the bus */
 
-    ec_device_t *device; /**< EtherCAT device */
-
     struct list_head datagram_queue; /**< datagram queue */
     uint8_t datagram_index; /**< current datagram index */
 
@@ -109,12 +115,17 @@
 
     struct workqueue_struct *workqueue; /**< master workqueue */
     struct work_struct idle_work; /**< free run work object */
-    ec_fsm_t fsm; /**< master state machine */
-    ec_master_mode_t mode; /**< master mode */
+    uint32_t idle_cycle_times[HZ]; /**< Idle cycle times ring */
+    unsigned int idle_cycle_time_pos; /**< time ring buffer position */
 
     struct timer_list eoe_timer; /**< EoE timer object */
+    uint32_t eoe_cycle_times[HZ]; /**< EoE cycle times ring */
+    unsigned int eoe_cycle_time_pos; /**< time ring buffer position */
     unsigned int eoe_running; /**< non-zero, if EoE processing is active. */
+    unsigned int eoe_checked; /**< non-zero, if EoE processing is not
+                                 necessary. */
     struct list_head eoe_handlers; /**< Ethernet-over-EtherCAT handlers */
+
     spinlock_t internal_lock; /**< spinlock used in idle mode */
     int (*request_cb)(void *); /**< lock request callback */
     void (*release_cb)(void *); /**< lock release callback */
@@ -139,7 +150,7 @@
 void ec_master_eoe_stop(ec_master_t *);
 
 // IO
-void ec_master_receive(ec_master_t *, const uint8_t *, size_t);
+void ec_master_receive_datagrams(ec_master_t *, const uint8_t *, size_t);
 void ec_master_queue_datagram(ec_master_t *, ec_datagram_t *);
 
 // slave management
@@ -148,6 +159,7 @@
 // misc.
 void ec_master_output_stats(ec_master_t *);
 void ec_master_clear_slaves(ec_master_t *);
+void ec_master_measure_bus_time(ec_master_t *);
 
 // other methods
 void ec_sync_config(const ec_sii_sync_t *, const ec_slave_t *, uint8_t *);

--- a/master/module.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/module.c	Wed Aug 09 14:38:44 2006 +0000
@@ -369,6 +369,7 @@
         return -1;
     }
 
+    ec_master_measure_bus_time(master);
     ec_master_idle_start(master);
     return 0;
 }
@@ -429,6 +430,7 @@
         goto out_release;
     }
 
+    ec_master_measure_bus_time(master);
     ec_master_idle_stop(master);
     ec_master_reset(master);
     master->mode = EC_MASTER_MODE_OPERATION;

--- a/master/slave.c	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/slave.c	Wed Aug 09 14:38:44 2006 +0000
@@ -155,6 +155,7 @@
     INIT_LIST_HEAD(&slave->sii_syncs);
     INIT_LIST_HEAD(&slave->sii_pdos);
     INIT_LIST_HEAD(&slave->sdo_dictionary);
+    INIT_LIST_HEAD(&slave->sdo_confs);
     INIT_LIST_HEAD(&slave->varsize_fields);
 
     for (i = 0; i < 4; i++) {
@@ -182,6 +183,7 @@
     ec_sii_pdo_entry_t *entry, *next_ent;
     ec_sdo_t *sdo, *next_sdo;
     ec_sdo_entry_t *en, *next_en;
+    ec_sdo_data_t *sdodata, *next_sdodata;
     ec_varsize_t *var, *next_var;
 
     slave = container_of(kobj, ec_slave_t, kobj);
@@ -231,6 +233,13 @@
         kfree(sdo);
     }
 
+    // free all SDO configurations
+    list_for_each_entry_safe(sdodata, next_sdodata, &slave->sdo_confs, list) {
+        list_del(&sdodata->list);
+        kfree(sdodata->data);
+        kfree(sdodata);
+    }
+
     // free information about variable sized data fields
     list_for_each_entry_safe(var, next_var, &slave->varsize_fields, list) {
         list_del(&var->list);
@@ -512,19 +521,18 @@
     if (slave->sii_name)
         off += sprintf(buffer + off, "%s", slave->sii_name);
 
-    off += sprintf(buffer + off, "\n\nVendor ID: 0x%08X\n",
+    off += sprintf(buffer + off, "\nVendor ID: 0x%08X\n",
                    slave->sii_vendor_id);
     off += sprintf(buffer + off, "Product code: 0x%08X\n\n",
                    slave->sii_product_code);
 
-    off += sprintf(buffer + off, "Ring position: %i\n", slave->ring_position);
+    off += sprintf(buffer + off, "State: ");
+    off += ec_state_string(slave->current_state, buffer + off);
+    off += sprintf(buffer + off, "\nRing position: %i\n",
+                   slave->ring_position);
     off += sprintf(buffer + off, "Advanced position: %i:%i\n\n",
                    slave->coupler_index, slave->coupler_subindex);
 
-    off += sprintf(buffer + off, "State: ");
-    off += ec_state_string(slave->current_state, buffer + off);
-    off += sprintf(buffer + off, "\n\n");
-
     off += sprintf(buffer + off, "Data link status:\n");
     for (i = 0; i < 4; i++) {
         off += sprintf(buffer + off, "  Port %i (", i);
@@ -602,7 +610,7 @@
     if (slave->sii_image)
         off += sprintf(buffer + off, "  Image: %s\n", slave->sii_image);
     if (slave->sii_order)
-        off += sprintf(buffer + off, "  Order#: %s\n", slave->sii_order);
+        off += sprintf(buffer + off, "  Order number: %s\n", slave->sii_order);
 
     if (!list_empty(&slave->sii_syncs))
         off += sprintf(buffer + off, "\nSync-Managers:\n");
@@ -620,13 +628,13 @@
 
     list_for_each_entry(pdo, &slave->sii_pdos, list) {
         off += sprintf(buffer + off,
-                       "  %s \"%s\" (0x%04X), -> Sync-Manager %i\n",
+                       "  %s \"%s\" (0x%04X), Sync-Manager %i\n",
                        pdo->type == EC_RX_PDO ? "RXPDO" : "TXPDO",
                        pdo->name ? pdo->name : "???",
                        pdo->index, pdo->sync_index);
 
         list_for_each_entry(pdo_entry, &pdo->entries, list) {
-            off += sprintf(buffer + off, "    \"%s\" 0x%04X:%X, %i Bit\n",
+            off += sprintf(buffer + off, "    \"%s\" 0x%04X:%X, %i bit\n",
                            pdo_entry->name ? pdo_entry->name : "???",
                            pdo_entry->index, pdo_entry->subindex,
                            pdo_entry->bit_length);
@@ -840,6 +848,7 @@
     ec_slave_t *slave = container_of(kobj, ec_slave_t, kobj);
 
     if (attr == &attr_state) {
+        char state[25];
         if (!strcmp(buffer, "INIT\n"))
             slave->requested_state = EC_SLAVE_STATE_INIT;
         else if (!strcmp(buffer, "PREOP\n"))
@@ -853,8 +862,9 @@
             return -EINVAL;
         }
 
+        ec_state_string(slave->requested_state, state);
         EC_INFO("Accepted new state %s for slave %i.\n",
-                buffer, slave->ring_position);
+                state, slave->ring_position);
         slave->error_flag = 0;
         return size;
     }
@@ -913,6 +923,47 @@
         && slave->sii_product_code == 0x044C2C52;
 }
 
+/*****************************************************************************/
+
+/**
+   \return 0 in case of success, else < 0
+*/
+
+int ec_slave_conf_sdo(ec_slave_t *slave, /**< EtherCAT slave */
+                      uint16_t sdo_index, /**< SDO index */
+                      uint8_t sdo_subindex, /**< SDO subindex */
+                      const uint8_t *data, /**< SDO data */
+                      size_t size /**< SDO size in bytes */
+                      )
+{
+    ec_sdo_data_t *sdodata;
+
+    if (!(slave->sii_mailbox_protocols & EC_MBOX_COE)) {
+        EC_ERR("Slave %i does not support CoE!\n", slave->ring_position);
+        return -1;
+    }
+
+    if (!(sdodata = (ec_sdo_data_t *)
+          kmalloc(sizeof(ec_sdo_data_t), GFP_KERNEL))) {
+        EC_ERR("Failed to allocate memory for SDO configuration object!\n");
+        return -1;
+    }
+
+    if (!(sdodata->data = (uint8_t *) kmalloc(size, GFP_KERNEL))) {
+        EC_ERR("Failed to allocate memory for SDO configuration data!\n");
+        kfree(sdodata);
+        return -1;
+    }
+
+    sdodata->index = sdo_index;
+    sdodata->subindex = sdo_subindex;
+    memcpy(sdodata->data, data, size);
+    sdodata->size = size;
+
+    list_add_tail(&sdodata->list, &slave->sdo_confs);
+    return 0;
+}
+
 /******************************************************************************
  *  Realtime interface
  *****************************************************************************/
@@ -922,6 +973,60 @@
    \ingroup RealtimeInterface
 */
 
+int ecrt_slave_conf_sdo8(ec_slave_t *slave, /**< EtherCAT slave */
+                         uint16_t sdo_index, /**< SDO index */
+                         uint8_t sdo_subindex, /**< SDO subindex */
+                         uint8_t value /**< new SDO value */
+                         )
+{
+    uint8_t data[1];
+    EC_WRITE_U8(data, value);
+    return ec_slave_conf_sdo(slave, sdo_index, sdo_subindex, data, 1);
+}
+
+/*****************************************************************************/
+
+/**
+   \return 0 in case of success, else < 0
+   \ingroup RealtimeInterface
+*/
+
+int ecrt_slave_conf_sdo16(ec_slave_t *slave, /**< EtherCAT slave */
+                          uint16_t sdo_index, /**< SDO index */
+                          uint8_t sdo_subindex, /**< SDO subindex */
+                          uint16_t value /**< new SDO value */
+                          )
+{
+    uint8_t data[2];
+    EC_WRITE_U16(data, value);
+    return ec_slave_conf_sdo(slave, sdo_index, sdo_subindex, data, 2);
+}
+
+/*****************************************************************************/
+
+/**
+   \return 0 in case of success, else < 0
+   \ingroup RealtimeInterface
+*/
+
+int ecrt_slave_conf_sdo32(ec_slave_t *slave, /**< EtherCAT slave */
+                          uint16_t sdo_index, /**< SDO index */
+                          uint8_t sdo_subindex, /**< SDO subindex */
+                          uint32_t value /**< new SDO value */
+                          )
+{
+    uint8_t data[4];
+    EC_WRITE_U32(data, value);
+    return ec_slave_conf_sdo(slave, sdo_index, sdo_subindex, data, 4);
+}
+
+/*****************************************************************************/
+
+/**
+   \return 0 in case of success, else < 0
+   \ingroup RealtimeInterface
+*/
+
 int ecrt_slave_pdo_size(ec_slave_t *slave, /**< EtherCAT slave */
                         uint16_t pdo_index, /**< PDO index */
                         uint8_t pdo_subindex, /**< PDO subindex */
@@ -989,6 +1094,9 @@
 
 /**< \cond */
 
+EXPORT_SYMBOL(ecrt_slave_conf_sdo8);
+EXPORT_SYMBOL(ecrt_slave_conf_sdo16);
+EXPORT_SYMBOL(ecrt_slave_conf_sdo32);
 EXPORT_SYMBOL(ecrt_slave_pdo_size);
 
 /**< \endcond */

--- a/master/slave.h	Thu Aug 03 12:59:01 2006 +0000
+++ b/master/slave.h	Wed Aug 09 14:38:44 2006 +0000
@@ -199,6 +199,18 @@
 
 /*****************************************************************************/
 
+typedef struct
+{
+    struct list_head list;
+    uint16_t index;
+    uint8_t subindex;
+    uint8_t *data;
+    size_t size;
+}
+ec_sdo_data_t;
+
+/*****************************************************************************/
+
 /**
    FMMU configuration.
 */
@@ -291,6 +303,7 @@
     uint8_t fmmu_count; /**< number of FMMUs used */
 
     struct list_head sdo_dictionary; /**< SDO directory list */
+    struct list_head sdo_confs; /**< list of SDO configurations */
 
     struct list_head varsize_fields; /**< size information for variable-sized
                                         data fields. */