fp@39: /******************************************************************************
fp@0:  *
fp@54:  *  m a s t e r . c
fp@0:  *
fp@0:  *  Methoden für einen EtherCAT-Master.
fp@0:  *
fp@39:  *  $Id$
fp@0:  *
fp@39:  *****************************************************************************/
fp@0: 
fp@24: #include <linux/module.h>
fp@0: #include <linux/kernel.h>
fp@0: #include <linux/string.h>
fp@0: #include <linux/slab.h>
fp@0: #include <linux/delay.h>
fp@0: 
fp@55: #include "../include/EtherCAT_rt.h"
fp@54: #include "globals.h"
fp@54: #include "master.h"
fp@55: #include "slave.h"
fp@55: #include "types.h"
fp@54: #include "device.h"
fp@54: #include "command.h"
fp@54: 
fp@54: /*****************************************************************************/
fp@54: 
fp@54: // Prototypen
fp@54: 
fp@54: int ec_simple_send(ec_master_t *, ec_command_t *);
fp@54: int ec_simple_receive(ec_master_t *, ec_command_t *);
fp@54: void ec_output_debug_data(const ec_master_t *);
fp@55: int ec_sii_read(ec_master_t *, unsigned short, unsigned short, unsigned int *);
fp@54: void ec_output_lost_frames(ec_master_t *);
fp@0: 
fp@39: /*****************************************************************************/
fp@0: 
fp@0: /**
fp@0:    Konstruktor des EtherCAT-Masters.
fp@0: 
fp@42:    @param master Zeiger auf den zu initialisierenden EtherCAT-Master
fp@0: */
fp@0: 
fp@54: void ec_master_init(ec_master_t *master)
fp@27: {
fp@52:   master->bus_slaves = NULL;
fp@52:   master->bus_slaves_count = 0;
fp@54:   master->device_registered = 0;
fp@0:   master->command_index = 0x00;
fp@0:   master->tx_data_length = 0;
fp@42:   master->rx_data_length = 0;
fp@42:   master->domain_count = 0;
fp@2:   master->debug_level = 0;
fp@47:   master->bus_time = 0;
fp@48:   master->frames_lost = 0;
fp@48:   master->t_lost_output = 0;
fp@0: }
fp@0: 
fp@39: /*****************************************************************************/
fp@0: 
fp@0: /**
fp@0:    Destruktor eines EtherCAT-Masters.
fp@0: 
fp@0:    Entfernt alle Kommandos aus der Liste, löscht den Zeiger
fp@0:    auf das Slave-Array und gibt die Prozessdaten frei.
fp@0: 
fp@0:    @param master Zeiger auf den zu löschenden Master
fp@0: */
fp@0: 
fp@54: void ec_master_clear(ec_master_t *master)
fp@0: {
fp@52:   if (master->bus_slaves) {
fp@52:     kfree(master->bus_slaves);
fp@52:     master->bus_slaves = NULL;
fp@42:   }
fp@42: 
fp@54:   ec_device_clear(&master->device);
fp@54: 
fp@42:   master->domain_count = 0;
fp@0: }
fp@0: 
fp@39: /*****************************************************************************/
fp@0: 
fp@0: /**
fp@56:    Setzt den Master in den Ausgangszustand.
fp@56: 
fp@56:    Bei einem "release" sollte immer diese Funktion aufgerufen werden,
fp@56:    da sonst Slave-Liste, Domains, etc. weiter existieren.
fp@56: 
fp@56:    @param master Zeiger auf den zurückzusetzenden Master
fp@56: */
fp@56: 
fp@56: void ec_master_reset(ec_master_t *master)
fp@56: {
fp@56:   if (master->bus_slaves) {
fp@56:     kfree(master->bus_slaves);
fp@56:     master->bus_slaves = NULL;
fp@56:   }
fp@56: 
fp@56:   master->bus_slaves_count = 0;
fp@56:   master->command_index = 0;
fp@56:   master->tx_data_length = 0;
fp@56:   master->rx_data_length = 0;
fp@56:   master->domain_count = 0;
fp@56:   master->debug_level = 0;
fp@56:   master->bus_time = 0;
fp@56:   master->frames_lost = 0;
fp@56:   master->t_lost_output = 0;
fp@56: }
fp@56: 
fp@56: /*****************************************************************************/
fp@56: 
fp@56: /**
fp@54:    Öffnet das EtherCAT-Geraet des Masters.
fp@54: 
fp@54:    @param master Der EtherCAT-Master
fp@54: 
fp@54:    @return 0, wenn alles o.k., < 0, wenn das Geraet nicht geoeffnet werden
fp@54:            konnte.
fp@54: */
fp@54: 
fp@54: int ec_master_open(ec_master_t *master)
fp@54: {
fp@54:   if (!master->device_registered) {
fp@54:     printk(KERN_ERR "EtherCAT: No device registered!\n");
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   if (ec_device_open(&master->device) < 0) {
fp@54:     printk(KERN_ERR "EtherCAT: Could not open device!\n");
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   return 0;
fp@54: }
fp@54: 
fp@54: /*****************************************************************************/
fp@54: 
fp@54: /**
fp@54:    Schliesst das EtherCAT-Geraet, auf dem der Master arbeitet.
fp@27: 
fp@27:    @param master Der EtherCAT-Master
fp@54: */
fp@54: 
fp@54: void ec_master_close(ec_master_t *master)
fp@54: {
fp@54:   if (!master->device_registered) {
fp@39:     printk(KERN_WARNING "EtherCAT: Warning -"
fp@54:            " Trying to close an unregistered device!\n");
fp@27:     return;
fp@27:   }
fp@27: 
fp@54:   if (ec_device_close(&master->device) < 0) {
fp@54:     printk(KERN_WARNING "EtherCAT: Warning - Could not close device!\n");
fp@54:   }
fp@27: }
fp@27: 
fp@39: /*****************************************************************************/
fp@27: 
fp@27: /**
fp@11:    Sendet ein einzelnes Kommando in einem Frame und
fp@11:    wartet auf dessen Empfang.
fp@11: 
fp@11:    @param master EtherCAT-Master
fp@11:    @param cmd    Kommando zum Senden/Empfangen
fp@11: 
fp@11:    @return 0 bei Erfolg, sonst < 0
fp@11: */
fp@11: 
fp@54: int ec_simple_send_receive(ec_master_t *master, ec_command_t *cmd)
fp@13: {
fp@13:   unsigned int tries_left;
fp@13: 
fp@54:   if (unlikely(ec_simple_send(master, cmd) < 0))
fp@54:     return -1;
fp@19: 
hm@29:   tries_left = 20;
fp@54: 
fp@54:   do
fp@54:   {
fp@19:     udelay(1);
fp@54:     ec_device_call_isr(&master->device);
fp@13:     tries_left--;
fp@13:   }
fp@54:   while (unlikely(master->device.state == EC_DEVICE_STATE_SENT && tries_left));
fp@54: 
fp@54:   if (unlikely(ec_simple_receive(master, cmd) < 0))
fp@39:     return -1;
fp@13: 
fp@13:   return 0;
fp@13: }
fp@13: 
fp@39: /*****************************************************************************/
fp@13: 
fp@13: /**
fp@13:    Sendet ein einzelnes Kommando in einem Frame.
fp@13: 
fp@13:    @param master EtherCAT-Master
fp@13:    @param cmd    Kommando zum Senden
fp@13: 
fp@13:    @return 0 bei Erfolg, sonst < 0
fp@13: */
fp@13: 
fp@54: int ec_simple_send(ec_master_t *master, ec_command_t *cmd)
fp@13: {
fp@13:   unsigned int length, framelength, i;
fp@11: 
fp@39:   if (unlikely(master->debug_level > 0)) {
fp@54:     printk(KERN_DEBUG "EtherCAT: ec_simple_send\n");
fp@54:   }
fp@54: 
fp@54:   if (unlikely(cmd->state != EC_COMMAND_STATE_READY)) {
fp@54:     printk(KERN_WARNING "EtherCAT: cmd not in ready state!\n");
fp@11:   }
fp@11: 
fp@11:   length = cmd->data_length + 12;
fp@11:   framelength = length + 2;
fp@19: 
fp@54:   if (unlikely(framelength > EC_FRAME_SIZE)) {
fp@42:     printk(KERN_ERR "EtherCAT: Frame too long (%i)!\n", framelength);
fp@19:     return -1;
fp@19:   }
fp@19: 
fp@11:   if (framelength < 46) framelength = 46;
fp@11: 
fp@39:   if (unlikely(master->debug_level > 0)) {
fp@54:     printk(KERN_DEBUG "EtherCAT: Frame length: %i\n", framelength);
fp@11:   }
fp@11: 
fp@11:   master->tx_data[0] = length & 0xFF;
fp@11:   master->tx_data[1] = ((length & 0x700) >> 8) | 0x10;
fp@11: 
fp@11:   cmd->index = master->command_index;
fp@11:   master->command_index = (master->command_index + 1) % 0x0100;
fp@11: 
fp@39:   if (unlikely(master->debug_level > 0)) {
fp@66:     printk(KERN_DEBUG "EtherCAT: Sending command index 0x%X\n", cmd->index);
fp@54:   }
fp@54: 
fp@54:   cmd->state = EC_COMMAND_STATE_SENT;
fp@11: 
fp@11:   master->tx_data[2 + 0] = cmd->type;
fp@11:   master->tx_data[2 + 1] = cmd->index;
fp@11:   master->tx_data[2 + 2] = cmd->address.raw[0];
fp@11:   master->tx_data[2 + 3] = cmd->address.raw[1];
fp@11:   master->tx_data[2 + 4] = cmd->address.raw[2];
fp@11:   master->tx_data[2 + 5] = cmd->address.raw[3];
fp@11:   master->tx_data[2 + 6] = cmd->data_length & 0xFF;
fp@11:   master->tx_data[2 + 7] = (cmd->data_length & 0x700) >> 8;
fp@11:   master->tx_data[2 + 8] = 0x00;
fp@11:   master->tx_data[2 + 9] = 0x00;
fp@11: 
fp@54:   if (likely(cmd->type == EC_COMMAND_APWR
fp@54:              || cmd->type == EC_COMMAND_NPWR
fp@54:              || cmd->type == EC_COMMAND_BWR
fp@54:              || cmd->type == EC_COMMAND_LRW)) // Write commands
fp@39:   {
fp@39:     for (i = 0; i < cmd->data_length; i++)
fp@39:       master->tx_data[2 + 10 + i] = cmd->data[i];
fp@39:   }
fp@39:   else // Read commands
fp@11:   {
fp@11:     for (i = 0; i < cmd->data_length; i++) master->tx_data[2 + 10 + i] = 0x00;
fp@11:   }
fp@11: 
fp@11:   master->tx_data[2 + 10 + cmd->data_length] = 0x00;
fp@11:   master->tx_data[2 + 11 + cmd->data_length] = 0x00;
fp@11: 
fp@11:   // Pad with zeros
fp@11:   for (i = cmd->data_length + 12 + 2; i < 46; i++) master->tx_data[i] = 0x00;
fp@11: 
fp@11:   master->tx_data_length = framelength;
fp@11: 
fp@39:   if (unlikely(master->debug_level > 0)) {
fp@54:     printk(KERN_DEBUG "EtherCAT: Device send...\n");
fp@11:   }
fp@11: 
fp@11:   // Send frame
fp@54:   if (unlikely(ec_device_send(&master->device, master->tx_data,
fp@54:                               framelength) != 0)) {
fp@26:     printk(KERN_ERR "EtherCAT: Could not send!\n");
fp@11:     return -1;
fp@11:   }
fp@11: 
fp@39:   if (unlikely(master->debug_level > 0)) {
fp@54:     printk(KERN_DEBUG "EtherCAT: ec_simple_send done.\n");
fp@11:   }
fp@11: 
fp@13:   return 0;
fp@13: }
fp@13: 
fp@39: /*****************************************************************************/
fp@13: 
fp@13: /**
fp@13:    Wartet auf den Empfang eines einzeln gesendeten
fp@13:    Kommandos.
fp@13: 
fp@13:    @param master EtherCAT-Master
fp@13:    @param cmd    Gesendetes Kommando
fp@13: 
fp@13:    @return 0 bei Erfolg, sonst < 0
fp@13: */
fp@13: 
fp@54: int ec_simple_receive(ec_master_t *master, ec_command_t *cmd)
fp@13: {
fp@19:   unsigned int length;
fp@39:   int ret;
fp@13:   unsigned char command_type, command_index;
fp@11: 
fp@64:   if (unlikely((ret = ec_device_receive(&master->device,
fp@64:                                         master->rx_data)) < 0))
fp@39:     return -1;
fp@39: 
fp@39:   master->rx_data_length = (unsigned int) ret;
fp@39: 
fp@39:   if (unlikely(master->rx_data_length < 2)) {
fp@48:     printk(KERN_ERR "EtherCAT: Received frame with incomplete EtherCAT"
fp@48:            " header!\n");
fp@54:     ec_output_debug_data(master);
fp@11:     return -1;
fp@11:   }
fp@11: 
fp@11:   // Länge des gesamten Frames prüfen
fp@39:   length = ((master->rx_data[1] & 0x07) << 8)
fp@39:     | (master->rx_data[0] & 0xFF);
fp@39: 
fp@39:   if (unlikely(length > master->rx_data_length)) {
fp@42:     printk(KERN_ERR "EtherCAT: Received corrupted frame (length does"
fp@42:            " not match)!\n");
fp@54:     ec_output_debug_data(master);
fp@11:     return -1;
fp@11:   }
fp@11: 
fp@11:   command_type = master->rx_data[2];
fp@11:   command_index = master->rx_data[2 + 1];
fp@39:   length = (master->rx_data[2 + 6] & 0xFF)
fp@39:     | ((master->rx_data[2 + 7] & 0x07) << 8);
fp@39: 
fp@39:   if (unlikely(master->rx_data_length - 2 < length + 12)) {
fp@39:     printk(KERN_ERR "EtherCAT: Received frame with"
fp@39:            " incomplete command data!\n");
fp@54:     ec_output_debug_data(master);
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   if (likely(cmd->state == EC_COMMAND_STATE_SENT
fp@39:              && cmd->type == command_type
fp@39:              && cmd->index == command_index
fp@39:              && cmd->data_length == length))
fp@11:   {
fp@54:     cmd->state = EC_COMMAND_STATE_RECEIVED;
fp@11: 
fp@11:     // Empfangene Daten in Kommandodatenspeicher kopieren
fp@11:     memcpy(cmd->data, master->rx_data + 2 + 10, length);
fp@11: 
fp@11:     // Working-Counter setzen
fp@42:     cmd->working_counter
fp@42:       = ((master->rx_data[length + 2 + 10] & 0xFF)
fp@42:          | ((master->rx_data[length + 2 + 11] & 0xFF) << 8));
fp@48: 
fp@48:     if (unlikely(master->debug_level > 1)) {
fp@54:       ec_output_debug_data(master);
fp@48:     }
fp@11:   }
fp@11:   else
fp@11:   {
fp@26:     printk(KERN_WARNING "EtherCAT: WARNING - Send/Receive anomaly!\n");
fp@54:     ec_output_debug_data(master);
fp@54:   }
fp@54: 
fp@54:   master->device.state = EC_DEVICE_STATE_READY;
fp@0: 
fp@0:   return 0;
fp@0: }
fp@0: 
fp@39: /*****************************************************************************/
fp@0: 
fp@17: /**
fp@52:    Durchsucht den Bus nach Slaves.
fp@17: 
fp@17:    @param master Der EtherCAT-Master
fp@17: 
fp@17:    @return 0 bei Erfolg, sonst < 0
fp@17: */
fp@17: 
fp@54: int ec_scan_for_slaves(ec_master_t *master)
fp@54: {
fp@54:   ec_command_t cmd;
fp@55:   ec_slave_t *slave;
fp@52:   unsigned int i, j;
fp@17:   unsigned char data[2];
fp@17: 
fp@17:   // Determine number of slaves on bus
fp@17: 
fp@54:   ec_command_broadcast_read(&cmd, 0x0000, 4);
fp@54: 
fp@54:   if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@39:     return -1;
fp@39: 
fp@52:   master->bus_slaves_count = cmd.working_counter;
fp@52:   printk("EtherCAT: Found %i slaves on bus.\n", master->bus_slaves_count);
fp@52: 
fp@52:   if (!master->bus_slaves_count) return 0;
fp@52: 
fp@54:   if (!(master->bus_slaves = (ec_slave_t *) kmalloc(master->bus_slaves_count
fp@54:                                                     * sizeof(ec_slave_t),
fp@54:                                                     GFP_KERNEL))) {
fp@52:     printk(KERN_ERR "EtherCAT: Could not allocate memory for bus slaves!\n");
fp@52:     return -1;
fp@52:   }
fp@17: 
fp@17:   // For every slave in the list
fp@52:   for (i = 0; i < master->bus_slaves_count; i++)
fp@52:   {
fp@55:     slave = master->bus_slaves + i;
fp@55: 
fp@55:     ec_slave_init(slave);
fp@55: 
fp@55:     // Set ring position
fp@63: 
fp@55:     slave->ring_position = -i;
fp@55:     slave->station_address = i + 1;
fp@55: 
fp@55:     // Write station address
fp@55: 
fp@55:     data[0] = slave->station_address & 0x00FF;
fp@55:     data[1] = (slave->station_address & 0xFF00) >> 8;
fp@55: 
fp@55:     ec_command_position_write(&cmd, slave->ring_position, 0x0010, 2, data);
fp@55: 
fp@55:     if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@55:       return -1;
fp@55: 
fp@55:     if (unlikely(cmd.working_counter != 1)) {
fp@55:       printk(KERN_ERR "EtherCAT: Slave %i did not repond while writing"
fp@55:              " station address!\n", i);
fp@55:       return -1;
fp@55:     }
fp@17: 
fp@17:     // Read base data
fp@17: 
fp@55:     ec_command_read(&cmd, slave->station_address, 0x0000, 4);
fp@54: 
fp@54:     if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@39:       return -1;
fp@39: 
fp@39:     if (unlikely(cmd.working_counter != 1)) {
fp@55:       printk(KERN_ERR "EtherCAT: Slave %i did not respond while reading base"
fp@55:              " data!\n", i);
fp@17:       return -1;
fp@17:     }
fp@17: 
fp@17:     // Get base data
fp@42: 
fp@55:     slave->base_type = cmd.data[0];
fp@55:     slave->base_revision = cmd.data[1];
fp@55:     slave->base_build = cmd.data[2] | (cmd.data[3] << 8);
fp@17: 
fp@17:     // Read identification from "Slave Information Interface" (SII)
fp@17: 
fp@55:     if (unlikely(ec_sii_read(master, slave->station_address, 0x0008,
fp@55:                              &slave->sii_vendor_id) != 0)) {
fp@26:       printk(KERN_ERR "EtherCAT: Could not read SII vendor id!\n");
fp@17:       return -1;
fp@17:     }
fp@17: 
fp@55:     if (unlikely(ec_sii_read(master, slave->station_address, 0x000A,
fp@55:                              &slave->sii_product_code) != 0)) {
fp@26:       printk(KERN_ERR "EtherCAT: Could not read SII product code!\n");
fp@17:       return -1;
fp@17:     }
fp@17: 
fp@55:     if (unlikely(ec_sii_read(master, slave->station_address, 0x000C,
fp@55:                              &slave->sii_revision_number) != 0)) {
fp@26:       printk(KERN_ERR "EtherCAT: Could not read SII revision number!\n");
fp@17:       return -1;
fp@17:     }
fp@17: 
fp@55:     if (unlikely(ec_sii_read(master, slave->station_address, 0x000E,
fp@55:                              &slave->sii_serial_number) != 0)) {
fp@26:       printk(KERN_ERR "EtherCAT: Could not read SII serial number!\n");
fp@17:       return -1;
fp@17:     }
fp@17: 
fp@17:     // Search for identification in "database"
fp@17: 
fp@39:     for (j = 0; j < slave_ident_count; j++)
fp@17:     {
fp@55:       if (unlikely(slave_idents[j].vendor_id == slave->sii_vendor_id
fp@55:                    && slave_idents[j].product_code == slave->sii_product_code))
fp@2:       {
fp@55:         slave->type = slave_idents[j].type;
fp@17:         break;
fp@2:       }
fp@17:     }
fp@17: 
fp@55:     if (unlikely(!slave->type)) {
fp@63:       printk(KERN_WARNING "EtherCAT: Unknown slave device (vendor 0x%08X, code"
fp@63:              " 0x%08X) at position %i.\n", slave->sii_vendor_id,
fp@63:              slave->sii_product_code, i);
fp@63:       return 0;
fp@52:     }
fp@42:   }
fp@17: 
fp@17:   return 0;
fp@17: }
fp@17: 
fp@39: /*****************************************************************************/
fp@17: 
fp@17: /**
fp@54:    Liest Daten aus dem Slave-Information-Interface
fp@54:    eines EtherCAT-Slaves.
fp@54: 
fp@54:    @param master EtherCAT-Master
fp@54:    @param node_address Knotenadresse des Slaves
fp@54:    @param offset Adresse des zu lesenden SII-Registers
fp@54:    @param target Zeiger auf einen 4 Byte großen Speicher
fp@54:    zum Ablegen der Daten
fp@54: 
fp@54:    @return 0 bei Erfolg, sonst < 0
fp@54: */
fp@54: 
fp@55: int ec_sii_read(ec_master_t *master, unsigned short int node_address,
fp@55:                 unsigned short int offset, unsigned int *target)
fp@54: {
fp@54:   ec_command_t cmd;
fp@54:   unsigned char data[10];
fp@54:   unsigned int tries_left;
fp@54: 
fp@54:   // Initiate read operation
fp@54: 
fp@54:   data[0] = 0x00;
fp@54:   data[1] = 0x01;
fp@54:   data[2] = offset & 0xFF;
fp@54:   data[3] = (offset & 0xFF00) >> 8;
fp@54:   data[4] = 0x00;
fp@54:   data[5] = 0x00;
fp@54: 
fp@54:   ec_command_write(&cmd, node_address, 0x502, 6, data);
fp@54: 
fp@54:   if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@54:     return -1;
fp@54: 
fp@54:   if (unlikely(cmd.working_counter != 1)) {
fp@54:     printk(KERN_ERR "EtherCAT: SII-read - Slave %04X did not respond!\n",
fp@54:            node_address);
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   // Der Slave legt die Informationen des Slave-Information-Interface
fp@54:   // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange
fp@54:   // den Status auslesen, bis das Bit weg ist.
fp@54: 
fp@54:   tries_left = 100;
fp@54:   while (likely(tries_left))
fp@54:   {
fp@54:     udelay(10);
fp@54: 
fp@54:     ec_command_read(&cmd, node_address, 0x502, 10);
fp@54: 
fp@54:     if (unlikely(ec_simple_send_receive(master, &cmd) != 0))
fp@54:       return -1;
fp@54: 
fp@54:     if (unlikely(cmd.working_counter != 1)) {
fp@54:       printk(KERN_ERR "EtherCAT: SII-read status -"
fp@54:              " Slave %04X did not respond!\n", node_address);
fp@54:       return -1;
fp@54:     }
fp@54: 
fp@54:     if (likely((cmd.data[1] & 0x81) == 0)) {
fp@54:       memcpy(target, cmd.data + 6, 4);
fp@54:       break;
fp@54:     }
fp@54: 
fp@54:     tries_left--;
fp@54:   }
fp@54: 
fp@54:   if (unlikely(!tries_left)) {
fp@54:     printk(KERN_WARNING "EtherCAT: SSI-read. Slave %04X timed out!\n",
fp@54:            node_address);
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   return 0;
fp@54: }
fp@54: 
fp@54: /*****************************************************************************/
fp@54: 
fp@54: /**
fp@54:    Ändert den Zustand eines Slaves (asynchron).
fp@54: 
fp@54:    Führt eine (asynchrone) Zustandsänderung bei einem Slave durch.
fp@54: 
fp@54:    @param master EtherCAT-Master
fp@54:    @param slave Slave, dessen Zustand geändert werden soll
fp@54:    @param state_and_ack Neuer Zustand, evtl. mit gesetztem
fp@54:    Acknowledge-Flag
fp@54: 
fp@54:    @return 0 bei Erfolg, sonst < 0
fp@54: */
fp@54: 
fp@54: int ec_state_change(ec_master_t *master, ec_slave_t *slave,
fp@54:                     unsigned char state_and_ack)
fp@54: {
fp@54:   ec_command_t cmd;
fp@54:   unsigned char data[2];
fp@54:   unsigned int tries_left;
fp@54: 
fp@54:   data[0] = state_and_ack;
fp@54:   data[1] = 0x00;
fp@54: 
fp@54:   ec_command_write(&cmd, slave->station_address, 0x0120, 2, data);
fp@54: 
fp@54:   if (unlikely(ec_simple_send_receive(master, &cmd) != 0)) {
fp@54:     printk(KERN_ERR "EtherCAT: Could not set state %02X - Unable to send!\n",
fp@54:            state_and_ack);
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   if (unlikely(cmd.working_counter != 1)) {
fp@63:     printk(KERN_ERR "EtherCAT: Could not set state %02X - Slave %i did not"
fp@63:            " respond!\n", state_and_ack, slave->ring_position * (-1));
fp@55:     return -1;
fp@55:   }
fp@54: 
fp@54:   tries_left = 100;
fp@54:   while (likely(tries_left))
fp@54:   {
fp@54:     udelay(10);
fp@54: 
fp@54:     ec_command_read(&cmd, slave->station_address, 0x0130, 2);
fp@54: 
fp@54:     if (unlikely(ec_simple_send_receive(master, &cmd) != 0)) {
fp@54:       printk(KERN_ERR "EtherCAT: Could not check state %02X - Unable to"
fp@54:              " send!\n", state_and_ack);
fp@54:       return -1;
fp@54:     }
fp@54: 
fp@54:     if (unlikely(cmd.working_counter != 1)) {
fp@63:       printk(KERN_ERR "EtherCAT: Could not check state %02X - Device %i did"
fp@63:              " not respond!\n", state_and_ack, slave->ring_position * (-1));
fp@54:       return -1;
fp@54:     }
fp@54: 
fp@54:     if (unlikely(cmd.data[0] & 0x10)) { // State change error
fp@63:       printk(KERN_ERR "EtherCAT: Could not set state %02X - Device %i refused"
fp@63:              " state change (code %02X)!\n", state_and_ack,
fp@63:              slave->ring_position * (-1), cmd.data[0]);
fp@54:       return -1;
fp@54:     }
fp@54: 
fp@54:     if (likely(cmd.data[0] == (state_and_ack & 0x0F))) {
fp@54:       // State change successful
fp@54:       break;
fp@54:     }
fp@54: 
fp@54:     tries_left--;
fp@54:   }
fp@54: 
fp@54:   if (unlikely(!tries_left)) {
fp@63:     printk(KERN_ERR "EtherCAT: Could not check state %02X of slave %i -"
fp@63:            " Timeout while checking!\n", state_and_ack,
fp@63:            slave->ring_position * (-1));
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   return 0;
fp@54: }
fp@54: 
fp@54: /*****************************************************************************/
fp@54: 
fp@54: /**
fp@54:    Gibt Frame-Inhalte zwecks Debugging aus.
fp@54: 
fp@54:    @param master EtherCAT-Master
fp@54: */
fp@54: 
fp@54: void ec_output_debug_data(const ec_master_t *master)
fp@54: {
fp@54:   unsigned int i;
fp@54: 
fp@54:   printk(KERN_DEBUG "EtherCAT: tx_data content (%i Bytes):\n",
fp@54:          master->tx_data_length);
fp@54: 
fp@54:   printk(KERN_DEBUG);
fp@54:   for (i = 0; i < master->tx_data_length; i++)
fp@54:   {
fp@54:     printk("%02X ", master->tx_data[i]);
fp@54:     if ((i + 1) % 16 == 0) printk("\n" KERN_DEBUG);
fp@54:   }
fp@54:   printk("\n");
fp@54: 
fp@54:   printk(KERN_DEBUG "EtherCAT: rx_data content (%i Bytes):\n",
fp@54:          master->rx_data_length);
fp@54: 
fp@54:   printk(KERN_DEBUG);
fp@54:   for (i = 0; i < master->rx_data_length; i++)
fp@54:   {
fp@54:     printk("%02X ", master->rx_data[i]);
fp@54:     if ((i + 1) % 16 == 0) printk("\n" KERN_DEBUG);
fp@54:   }
fp@54:   printk("\n");
fp@54: }
fp@54: 
fp@54: /*****************************************************************************/
fp@54: 
fp@54: /**
fp@54:    Gibt von Zeit zu Zeit die Anzahl verlorener Frames aus.
fp@54: 
fp@54:    @param master EtherCAT-Master
fp@54: */
fp@54: 
fp@54: void ec_output_lost_frames(ec_master_t *master)
fp@54: {
fp@54:   unsigned long int t;
fp@54: 
fp@54:   if (master->frames_lost) {
fp@54:     rdtscl(t);
fp@54:     if ((t - master->t_lost_output) / cpu_khz > 1000) {
fp@54:       printk(KERN_ERR "EtherCAT: %u frame(s) LOST!\n", master->frames_lost);
fp@54:       master->frames_lost = 0;
fp@54:       master->t_lost_output = t;
fp@54:     }
fp@54:   }
fp@54: }
fp@54: 
fp@54: /******************************************************************************
fp@54:  *
fp@54:  * Echtzeitschnittstelle
fp@54:  *
fp@54:  *****************************************************************************/
fp@54: 
fp@54: /**
fp@52:    Registriert einen Slave beim Master.
fp@52: 
fp@52:    @param master Der EtherCAT-Master
fp@58:    @param bus_index Index des Slaves im EtherCAT-Bus
fp@58:    @param vendor_name String mit dem Herstellernamen
fp@58:    @param product_name String mit dem Produktnamen
fp@58:    @param domain Domäne, in der der Slave sein soll
fp@52: 
fp@61:    @return Zeiger auf den Slave bei Erfolg, sonst NULL
fp@52: */
fp@52: 
fp@55: ec_slave_t *EtherCAT_rt_register_slave(ec_master_t *master,
fp@55:                                        unsigned int bus_index,
fp@55:                                        const char *vendor_name,
fp@55:                                        const char *product_name,
fp@56:                                        int domain)
fp@54: {
fp@54:   ec_slave_t *slave;
fp@55:   const ec_slave_type_t *type;
fp@54:   ec_domain_t *dom;
fp@52:   unsigned int j;
fp@52: 
fp@56:   if (domain < 0) {
fp@56:     printk(KERN_ERR "EtherCAT: Invalid domain: %i\n", domain);
fp@56:     return NULL;
fp@56:   }
fp@56: 
fp@52:   if (bus_index >= master->bus_slaves_count) {
fp@52:     printk(KERN_ERR "EtherCAT: Illegal bus index! (%i / %i)\n", bus_index,
fp@52:            master->bus_slaves_count);
fp@52:     return NULL;
fp@52:   }
fp@52: 
fp@52:   slave = master->bus_slaves + bus_index;
fp@52: 
fp@55:   if (slave->registered) {
fp@52:     printk(KERN_ERR "EtherCAT: Slave %i is already registered!\n", bus_index);
fp@52:     return NULL;
fp@52:   }
fp@52: 
fp@63:   if (!slave->type) {
fp@63:     printk(KERN_ERR "EtherCAT: Unknown slave at position %i!\n", bus_index);
fp@63:     return NULL;
fp@63:   }
fp@63: 
fp@55:   type = slave->type;
fp@55: 
fp@55:   if (strcmp(vendor_name, type->vendor_name) ||
fp@55:       strcmp(product_name, type->product_name)) {
fp@56:     printk(KERN_ERR "Invalid Slave Type! Requested: \"%s %s\", found: \"%s"
fp@55:            " %s\".\n", vendor_name, product_name, type->vendor_name,
fp@55:            type->product_name);
fp@52:     return NULL;
fp@52:   }
fp@52: 
fp@52:   // Check, if process data domain already exists...
fp@52:   dom = NULL;
fp@52:   for (j = 0; j < master->domain_count; j++) {
fp@52:     if (domain == master->domains[j].number) {
fp@52:       dom = master->domains + j;
fp@56:       break;
fp@52:     }
fp@52:   }
fp@52: 
fp@52:   // Create process data domain
fp@52:   if (!dom) {
fp@54:     if (master->domain_count > EC_MAX_DOMAINS - 1) {
fp@52:       printk(KERN_ERR "EtherCAT: Too many domains!\n");
fp@52:       return NULL;
fp@52:     }
fp@52: 
fp@52:     dom = master->domains + master->domain_count;
fp@54:     ec_domain_init(dom);
fp@52:     dom->number = domain;
fp@54:     dom->logical_offset = master->domain_count * EC_FRAME_SIZE;
fp@52:     master->domain_count++;
fp@52:   }
fp@52: 
fp@55:   if (dom->data_size + type->process_data_size > EC_FRAME_SIZE - 14) {
fp@52:     printk(KERN_ERR "EtherCAT: Oversized domain %i: %i / %i Bytes!\n",
fp@55:            dom->number, dom->data_size + type->process_data_size,
fp@54:            EC_FRAME_SIZE - 14);
fp@52:     return NULL;
fp@52:   }
fp@52: 
fp@52:   slave->process_data = dom->data + dom->data_size;
fp@56:   slave->logical_address = dom->data_size;
fp@56:   slave->registered = 1;
fp@56: 
fp@55:   dom->data_size += type->process_data_size;
fp@55: 
fp@55:   return slave;
fp@52: }
fp@52: 
fp@52: /*****************************************************************************/
fp@52: 
fp@52: /**
fp@61:    Registriert eine ganze Liste von Slaves beim Master.
fp@61: 
fp@61:    @param master Der EtherCAT-Master
fp@61:    @param slaves Array von Slave-Initialisierungsstrukturen
fp@61:    @param count Anzahl der Strukturen in "slaves"
fp@61: 
fp@61:    @return 0 bei Erfolg, sonst < 0
fp@61: */
fp@61: 
fp@61: int EtherCAT_rt_register_slave_list(ec_master_t *master,
fp@61:                                     const ec_slave_init_t *slaves,
fp@61:                                     unsigned int count)
fp@61: {
fp@61:   unsigned int i;
fp@61: 
fp@61:   for (i = 0; i < count; i++)
fp@61:   {
fp@61:     if ((*(slaves[i].slave_ptr) =
fp@61:          EtherCAT_rt_register_slave(master, slaves[i].bus_index,
fp@61:                                     slaves[i].vendor_name,
fp@61:                                     slaves[i].product_name,
fp@61:                                     slaves[i].domain)) == NULL)
fp@61:       return -1;
fp@61:   }
fp@61: 
fp@61:   return 0;
fp@61: }
fp@61: 
fp@61: /*****************************************************************************/
fp@61: 
fp@61: /**
fp@58:    Konfiguriert alle Slaves und setzt den Operational-Zustand.
fp@58: 
fp@58:    Führt die komplette Konfiguration und Aktivierunge aller registrierten
fp@58:    Slaves durch. Setzt Sync-Manager und FMMU's, führt die entsprechenden
fp@0:    Zustandsübergänge durch, bis der Slave betriebsbereit ist.
fp@0: 
fp@0:    @param master EtherCAT-Master
fp@8: 
fp@0:    @return 0 bei Erfolg, sonst < 0
fp@0: */
fp@0: 
fp@54: int EtherCAT_rt_activate_slaves(ec_master_t *master)
fp@54: {
fp@54:   unsigned int i;
fp@54:   ec_slave_t *slave;
fp@54:   ec_command_t cmd;
fp@55:   const ec_slave_type_t *type;
fp@0:   unsigned char fmmu[16];
fp@0:   unsigned char data[256];
fp@0: 
fp@54:   for (i = 0; i < master->bus_slaves_count; i++)
fp@0:   {
fp@54:     slave = master->bus_slaves + i;
fp@63: 
fp@63:     if (unlikely(ec_state_change(master, slave, EC_SLAVE_STATE_INIT) != 0))
fp@63:       return -1;
fp@63: 
fp@63:     // Check if slave was registered...
fp@63:     if (!slave->registered) {
fp@63:       printk(KERN_INFO "EtherCAT: Slave %i was not registered.\n", i);
fp@63:       continue;
fp@63:     }
fp@63: 
fp@55:     type = slave->type;
fp@54: 
fp@54:     // Resetting FMMU's
fp@54: 
fp@0:     memset(data, 0x00, 256);
fp@0: 
fp@54:     ec_command_write(&cmd, slave->station_address, 0x0600, 256, data);
fp@54: 
fp@54:     if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@39:       return -1;
fp@39: 
fp@39:     if (unlikely(cmd.working_counter != 1)) {
fp@54:       printk(KERN_ERR "EtherCAT: Resetting FMMUs - Slave %04X did not"
fp@43:              " respond!\n", slave->station_address);
fp@42:       return -1;
fp@0:     }
fp@54: 
fp@54:     // Resetting Sync Manager channels
fp@54: 
fp@55:     if (type->features != EC_NOSYNC_SLAVE)
fp@0:     {
fp@54:       memset(data, 0x00, 256);
fp@54: 
fp@54:       ec_command_write(&cmd, slave->station_address, 0x0800, 256, data);
fp@54: 
fp@54:       if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@39:         return -1;
fp@39: 
fp@39:       if (unlikely(cmd.working_counter != 1)) {
fp@54:         printk(KERN_ERR "EtherCAT: Resetting SMs - Slave %04X did not"
fp@43:                " respond!\n", slave->station_address);
fp@42:         return -1;
fp@0:       }
fp@0:     }
fp@0: 
fp@54:     // Init Mailbox communication
fp@54: 
fp@55:     if (type->features == EC_MAILBOX_SLAVE)
fp@0:     {
fp@55:       if (type->sm0)
fp@54:       {
fp@55:         ec_command_write(&cmd, slave->station_address, 0x0800, 8, type->sm0);
fp@54: 
fp@54:         if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@54:           return -1;
fp@54: 
fp@54:         if (unlikely(cmd.working_counter != 1)) {
fp@54:           printk(KERN_ERR "EtherCAT: Setting SM0 - Slave %04X did not"
fp@54:                  " respond!\n", slave->station_address);
fp@54:           return -1;
fp@54:         }
fp@54:       }
fp@54: 
fp@55:       if (type->sm1)
fp@54:       {
fp@55:         ec_command_write(&cmd, slave->station_address, 0x0808, 8, type->sm1);
fp@54: 
fp@54:         if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@54:           return -1;
fp@54: 
fp@54:         if (unlikely(cmd.working_counter != 1)) {
fp@54:           printk(KERN_ERR "EtherCAT: Setting SM1 -"
fp@54:                  " Slave %04X did not respond!\n",
fp@54:                  slave->station_address);
fp@54:           return -1;
fp@54:         }
fp@54:       }
fp@54:     }
fp@54: 
fp@54:     // Change state to PREOP
fp@54: 
fp@54:     if (unlikely(ec_state_change(master, slave, EC_SLAVE_STATE_PREOP) != 0))
fp@54:       return -1;
fp@54: 
fp@54:     // Set FMMU's
fp@54: 
fp@55:     if (type->fmmu0)
fp@54:     {
fp@54:       if (unlikely(!slave->process_data)) {
fp@54:         printk(KERN_ERR "EtherCAT: Warning - Slave %04X is not assigned to any"
fp@54:                " process data object!\n", slave->station_address);
fp@42:         return -1;
fp@0:       }
fp@54: 
fp@55:       memcpy(fmmu, type->fmmu0, 16);
fp@54: 
fp@54:       fmmu[0] = slave->logical_address & 0x000000FF;
fp@54:       fmmu[1] = (slave->logical_address & 0x0000FF00) >> 8;
fp@54:       fmmu[2] = (slave->logical_address & 0x00FF0000) >> 16;
fp@54:       fmmu[3] = (slave->logical_address & 0xFF000000) >> 24;
fp@54: 
fp@54:       ec_command_write(&cmd, slave->station_address, 0x0600, 16, fmmu);
fp@54: 
fp@54:       if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@39:         return -1;
fp@39: 
fp@39:       if (unlikely(cmd.working_counter != 1)) {
fp@54:         printk(KERN_ERR "EtherCAT: Setting FMMU0 - Slave %04X did not"
fp@43:                " respond!\n", slave->station_address);
fp@42:         return -1;
fp@0:       }
fp@0:     }
fp@0: 
fp@54:     // Set Sync Managers
fp@54: 
fp@55:     if (type->features != EC_MAILBOX_SLAVE)
fp@0:     {
fp@55:       if (type->sm0)
fp@54:       {
fp@55:         ec_command_write(&cmd, slave->station_address, 0x0800, 8, type->sm0);
fp@54: 
fp@54:         if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@54:           return -1;
fp@54: 
fp@54:         if (unlikely(cmd.working_counter != 1)) {
fp@54:           printk(KERN_ERR "EtherCAT: Setting SM0 - Slave %04X did not"
fp@54:                  " respond!\n", slave->station_address);
fp@54:           return -1;
fp@54:         }
fp@54:       }
fp@54: 
fp@55:       if (type->sm1)
fp@54:       {
fp@55:         ec_command_write(&cmd, slave->station_address, 0x0808, 8, type->sm1);
fp@54: 
fp@54:         if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@54:           return -1;
fp@54: 
fp@54:         if (unlikely(cmd.working_counter != 1)) {
fp@54:           printk(KERN_ERR "EtherCAT: Setting SM1 - Slave %04X did not"
fp@54:                  " respond!\n", slave->station_address);
fp@54:           return -1;
fp@54:         }
fp@54:       }
fp@54:     }
fp@54: 
fp@55:     if (type->sm2)
fp@54:     {
fp@55:       ec_command_write(&cmd, slave->station_address, 0x0810, 8, type->sm2);
fp@54: 
fp@54:       if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@39:         return -1;
fp@39: 
fp@39:       if (unlikely(cmd.working_counter != 1)) {
fp@54:         printk(KERN_ERR "EtherCAT: Setting SM2 - Slave %04X did not"
fp@43:                " respond!\n", slave->station_address);
fp@42:         return -1;
fp@0:       }
fp@8:     }
fp@54: 
fp@55:     if (type->sm3)
fp@54:     {
fp@55:       ec_command_write(&cmd, slave->station_address, 0x0818, 8, type->sm3);
fp@54: 
fp@54:       if (unlikely(ec_simple_send_receive(master, &cmd) < 0))
fp@54:         return -1;
fp@54: 
fp@54:       if (unlikely(cmd.working_counter != 1)) {
fp@54:         printk(KERN_ERR "EtherCAT: Setting SM3 - Slave %04X did not"
fp@54:                " respond!\n", slave->station_address);
fp@54:         return -1;
fp@54:       }
fp@54:     }
fp@54: 
fp@54:     // Change state to SAVEOP
fp@54:     if (unlikely(ec_state_change(master, slave, EC_SLAVE_STATE_SAVEOP) != 0))
fp@54:       return -1;
fp@54: 
fp@54:     // Change state to OP
fp@54:     if (unlikely(ec_state_change(master, slave, EC_SLAVE_STATE_OP) != 0))
fp@54:       return -1;
fp@54:   }
fp@0: 
fp@0:   return 0;
fp@0: }
fp@0: 
fp@39: /*****************************************************************************/
fp@0: 
fp@0: /**
fp@58:    Setzt alle Slaves zurück in den Init-Zustand.
fp@0: 
fp@0:    @param master EtherCAT-Master
fp@8: 
fp@0:    @return 0 bei Erfolg, sonst < 0
fp@0: */
fp@0: 
fp@54: int EtherCAT_rt_deactivate_slaves(ec_master_t *master)
fp@54: {
fp@54:   ec_slave_t *slave;
fp@54:   unsigned int i;
fp@54: 
fp@54:   for (i = 0; i < master->bus_slaves_count; i++)
fp@54:   {
fp@61:     slave = master->bus_slaves + i;
fp@54: 
fp@54:     if (unlikely(ec_state_change(master, slave, EC_SLAVE_STATE_INIT) != 0))
fp@54:       return -1;
fp@54:   }
fp@0: 
fp@0:   return 0;
fp@0: }
fp@0: 
fp@39: /*****************************************************************************/
fp@0: 
fp@0: /**
fp@42:    Sendet und empfängt Prozessdaten der angegebenen Domäne
fp@0: 
fp@58:    @param master EtherCAT-Master
fp@58:    @param domain Domäne
fp@58:    @param timeout_us Timeout in Mikrosekunden
fp@8: 
fp@0:    @return 0 bei Erfolg, sonst < 0
fp@0: */
fp@0: 
fp@56: int EtherCAT_rt_domain_xio(ec_master_t *master, unsigned int domain,
fp@56:                            unsigned int timeout_us)
fp@47: {
fp@47:   unsigned int i;
fp@54:   ec_domain_t *dom;
fp@47:   unsigned long start_ticks, end_ticks, timeout_ticks;
fp@47: 
fp@54:   ec_output_lost_frames(master); // Evtl. verlorene Frames ausgeben
fp@48: 
fp@48:   // Domäne bestimmen
fp@47:   dom = NULL;
fp@42:   for (i = 0; i < master->domain_count; i++) {
fp@42:     if (master->domains[i].number == domain) {
fp@42:       dom = master->domains + i;
fp@42:       break;
fp@42:     }
fp@42:   }
fp@42: 
fp@42:   if (unlikely(!dom)) {
fp@42:     printk(KERN_ERR "EtherCAT: No such domain: %i!\n", domain);
fp@42:     return -1;
fp@42:   }
fp@42: 
fp@54:   ec_command_logical_read_write(&dom->command, dom->logical_offset,
fp@54:                                 dom->data_size, dom->data);
fp@42: 
fp@47:   rdtscl(start_ticks); // Sendezeit nehmen
fp@47: 
fp@54:   if (unlikely(ec_simple_send(master, &dom->command) < 0)) {
fp@42:     printk(KERN_ERR "EtherCAT: Could not send process data command!\n");
fp@42:     return -1;
fp@42:   }
fp@42: 
fp@47:   timeout_ticks = timeout_us * cpu_khz / 1000;
fp@47: 
fp@42:   // Warten
fp@47:   do {
fp@54:     ec_device_call_isr(&master->device);
fp@47:     rdtscl(end_ticks); // Empfangszeit nehmen
fp@47:   }
fp@54:   while (unlikely(master->device.state == EC_DEVICE_STATE_SENT
fp@47:                   && end_ticks - start_ticks < timeout_ticks));
fp@47: 
fp@47:   master->bus_time = (end_ticks - start_ticks) * 1000 / cpu_khz;
fp@47: 
fp@47:   if (unlikely(end_ticks - start_ticks >= timeout_ticks)) {
fp@54:     master->device.state = EC_DEVICE_STATE_READY;
fp@48:     master->frames_lost++;
fp@54:     ec_output_lost_frames(master);
fp@54:     return -1;
fp@54:   }
fp@54: 
fp@54:   if (unlikely(ec_simple_receive(master, &dom->command) < 0)) {
fp@26:     printk(KERN_ERR "EtherCAT: Could not receive cyclic command!\n");
fp@0:     return -1;
fp@0:   }
fp@0: 
fp@54:   if (unlikely(dom->command.state != EC_COMMAND_STATE_RECEIVED)) {
fp@26:     printk(KERN_WARNING "EtherCAT: Process data command not received!\n");
fp@13:     return -1;
fp@13:   }
fp@13: 
fp@48:   if (dom->command.working_counter != dom->response_count) {
fp@48:     dom->response_count = dom->command.working_counter;
fp@48:     printk(KERN_INFO "EtherCAT: Domain %i State change - %i slaves"
fp@48:            " responding.\n", dom->number, dom->response_count);
fp@48:   }
fp@48: 
fp@42:   // Daten vom Kommando in den Prozessdatenspeicher kopieren
fp@42:   memcpy(dom->data, dom->command.data, dom->data_size);
fp@13: 
fp@13:   return 0;
fp@13: }
fp@13: 
fp@39: /*****************************************************************************/
fp@13: 
fp@56: /**
fp@56:    Setzt die Debug-Ebene des Masters.
fp@56: */
fp@56: 
fp@56: void EtherCAT_rt_debug_level(ec_master_t *master, int level)
fp@56: {
fp@56:   master->debug_level = level;
fp@56: }
fp@56: 
fp@56: /*****************************************************************************/
fp@56: 
fp@54: EXPORT_SYMBOL(EtherCAT_rt_register_slave);
fp@61: EXPORT_SYMBOL(EtherCAT_rt_register_slave_list);
fp@54: EXPORT_SYMBOL(EtherCAT_rt_activate_slaves);
fp@54: EXPORT_SYMBOL(EtherCAT_rt_deactivate_slaves);
fp@56: EXPORT_SYMBOL(EtherCAT_rt_domain_xio);
fp@56: EXPORT_SYMBOL(EtherCAT_rt_debug_level);
fp@42: 
fp@42: /*****************************************************************************/
fp@42: 
fp@42: /* Emacs-Konfiguration
fp@42: ;;; Local Variables: ***
fp@42: ;;; c-basic-offset:2 ***
fp@42: ;;; End: ***
fp@42: */