# HG changeset patch # User Florian Pose # Date 1134979991 0 # Node ID 6965c23a6826214a7cb4d44b2e22365d66582e23 # Parent 3213cbbd58b7380263d484dba7441d6a5fada54d likely/unlikely, Fehlermeldungen in zyklischem Code begrenzt und Kommentare ge??ndert. diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/8139too.c --- a/drivers/8139too.c Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/8139too.c Mon Dec 19 08:13:11 2005 +0000 @@ -6,8 +6,8 @@ * * Autoren: Wilhelm Hagemeister, Florian Pose * - * $Date: 2005-11-18 11:30:01 +0100 (Fre, 18 Nov 2005) $ - * $Author: fp $ + * $Date$ + * $Author$ * * (C) Copyright IgH 2005 * Ingenieurgemeinschaft IgH diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_command.c --- a/drivers/ec_command.c Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_command.c Mon Dec 19 08:13:11 2005 +0000 @@ -1,19 +1,18 @@ -/**************************************************************** +/****************************************************************************** * * e c _ c o m m a n d . c * * Methoden für ein EtherCAT-Kommando. * - * $Date$ - * $Author$ - * - ***************************************************************/ + * $Id$ + * + *****************************************************************************/ #include #include "ec_command.h" -/***************************************************************/ +/*****************************************************************************/ /** Kommando-Konstruktor. @@ -34,7 +33,7 @@ cmd->working_counter = 0; } -/***************************************************************/ +/*****************************************************************************/ /** Kommando-Destruktor. @@ -49,7 +48,7 @@ EtherCAT_command_init(cmd); } -/***************************************************************/ +/*****************************************************************************/ #define ECAT_FUNC_HEADER \ EtherCAT_command_init(cmd) @@ -61,7 +60,7 @@ #define ECAT_FUNC_READ_FOOTER \ cmd->data_length = length; -/***************************************************************/ +/*****************************************************************************/ /** Initialisiert ein EtherCAT-NPRD-Kommando. @@ -77,8 +76,8 @@ unsigned short offset, unsigned int length) { - if (node_address == 0x0000) - printk(KERN_WARNING "EtherCAT: Using node address 0x0000!\n"); + if (unlikely(node_address == 0x0000)) + printk(KERN_WARNING "EtherCAT: Warning - Using node address 0x0000!\n"); ECAT_FUNC_HEADER; @@ -89,7 +88,7 @@ ECAT_FUNC_READ_FOOTER; } -/***************************************************************/ +/*****************************************************************************/ /** Initialisiert ein EtherCAT-NPWR-Kommando. @@ -110,8 +109,8 @@ unsigned int length, const unsigned char *data) { - if (node_address == 0x0000) - printk(KERN_WARNING "EtherCAT: Using node address 0x0000!\n"); + if (unlikely(node_address == 0x0000)) + printk(KERN_WARNING "EtherCAT: Warning - Using node address 0x0000!\n"); ECAT_FUNC_HEADER; @@ -122,7 +121,7 @@ ECAT_FUNC_WRITE_FOOTER; } -/***************************************************************/ +/*****************************************************************************/ /** Initialisiert ein EtherCAT-APRD-Kommando. @@ -150,7 +149,7 @@ ECAT_FUNC_READ_FOOTER; } -/***************************************************************/ +/*****************************************************************************/ /** Initialisiert ein EtherCAT-APWR-Kommando. @@ -180,7 +179,7 @@ ECAT_FUNC_WRITE_FOOTER; } -/***************************************************************/ +/*****************************************************************************/ /** Initialisiert ein EtherCAT-BRD-Kommando. @@ -206,7 +205,7 @@ ECAT_FUNC_READ_FOOTER; } -/***************************************************************/ +/*****************************************************************************/ /** Initialisiert ein EtherCAT-BWR-Kommando. @@ -234,7 +233,7 @@ ECAT_FUNC_WRITE_FOOTER; } -/***************************************************************/ +/*****************************************************************************/ /** Initialisiert ein EtherCAT-LRW-Kommando. @@ -261,4 +260,4 @@ ECAT_FUNC_WRITE_FOOTER; } -/***************************************************************/ +/*****************************************************************************/ diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_command.h --- a/drivers/ec_command.h Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_command.h Mon Dec 19 08:13:11 2005 +0000 @@ -1,13 +1,12 @@ -/**************************************************************** +/****************************************************************************** * * e c _ c o m m a n d . h * * Struktur für ein EtherCAT-Kommando. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #ifndef _EC_COMMAND_H_ #define _EC_COMMAND_H_ @@ -57,7 +56,7 @@ } EtherCAT_address_t; -/***************************************************************/ +/*****************************************************************************/ /** EtherCAT-Kommando. @@ -67,18 +66,21 @@ { EtherCAT_cmd_type_t type; /**< Typ des Kommandos (APRD, NPWR, etc...) */ EtherCAT_address_t address; /**< Adresse des/der Empfänger */ - unsigned int data_length; /**< Länge der zu sendenden und/oder empfangenen Daten */ + unsigned int data_length; /**< Länge der zu sendenden und/oder + empfangenen Daten */ - EtherCAT_command_state_t state; /**< Zustand des Kommandos (bereit, gesendet, etc...) */ - unsigned char index; /**< Kommando-Index, mit der das Kommando gesendet wurde (wird - vom Master beim Senden gesetzt. */ - unsigned int working_counter; /**< Working-Counter bei Empfang (wird vom Master gesetzt) */ + EtherCAT_command_state_t state; /**< Zustand des Kommandos + (bereit, gesendet, etc...) */ + unsigned char index; /**< Kommando-Index, mit der das Kommando gesendet + wurde (wird vom Master beim Senden gesetzt. */ + unsigned int working_counter; /**< Working-Counter bei Empfang (wird + vom Master gesetzt) */ unsigned char data[ECAT_FRAME_BUFFER_SIZE]; /**< Kommandodaten */ } EtherCAT_command_t; -/***************************************************************/ +/*****************************************************************************/ void EtherCAT_command_init(EtherCAT_command_t *); void EtherCAT_command_clear(EtherCAT_command_t *); @@ -113,6 +115,6 @@ unsigned int, unsigned char *); -/***************************************************************/ +/*****************************************************************************/ #endif diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_device.c --- a/drivers/ec_device.c Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_device.c Mon Dec 19 08:13:11 2005 +0000 @@ -1,13 +1,12 @@ -/**************************************************************** +/****************************************************************************** * * e c _ d e v i c e . c * * Methoden für ein EtherCAT-Gerät. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #include #include @@ -17,7 +16,7 @@ #include "ec_device.h" -/***************************************************************/ +/*****************************************************************************/ /** EtherCAT-Geräte-Konstuktor. @@ -42,9 +41,10 @@ ecd->rx_data_length = 0; ecd->isr = NULL; ecd->module = NULL; -} - -/***************************************************************/ + ecd->error_reported = 0; +} + +/*****************************************************************************/ /** EtherCAT-Geräte-Destuktor. @@ -59,20 +59,18 @@ { ecd->dev = NULL; - if (ecd->tx_skb) - { + if (ecd->tx_skb) { dev_kfree_skb(ecd->tx_skb); ecd->tx_skb = NULL; } - if (ecd->rx_skb) - { + if (ecd->rx_skb) { dev_kfree_skb(ecd->rx_skb); ecd->rx_skb = NULL; } } -/***************************************************************/ +/*****************************************************************************/ /** Weist einem EtherCAT-Gerät das entsprechende net_device zu. @@ -90,23 +88,19 @@ int EtherCAT_device_assign(EtherCAT_device_t *ecd, struct net_device *dev) { - if (!dev) - { + if (!dev) { printk("EtherCAT: Device is NULL!\n"); return -1; } - if ((ecd->tx_skb = dev_alloc_skb(ECAT_FRAME_BUFFER_SIZE)) == NULL) - { + if ((ecd->tx_skb = dev_alloc_skb(ECAT_FRAME_BUFFER_SIZE)) == NULL) { printk(KERN_ERR "EtherCAT: Could not allocate device tx socket buffer!\n"); return -1; } - if ((ecd->rx_skb = dev_alloc_skb(ECAT_FRAME_BUFFER_SIZE)) == NULL) - { + if ((ecd->rx_skb = dev_alloc_skb(ECAT_FRAME_BUFFER_SIZE)) == NULL) { dev_kfree_skb(ecd->tx_skb); ecd->tx_skb = NULL; - printk(KERN_ERR "EtherCAT: Could not allocate device rx socket buffer!\n"); return -1; } @@ -120,7 +114,7 @@ return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Führt die open()-Funktion des Netzwerktreibers aus. @@ -137,14 +131,12 @@ int EtherCAT_device_open(EtherCAT_device_t *ecd) { - if (!ecd) - { + if (!ecd) { printk(KERN_ERR "EtherCAT: Trying to open a NULL device!\n"); return -1; } - if (!ecd->dev) - { + if (!ecd->dev) { printk(KERN_ERR "EtherCAT: No net_device to open!\n"); return -1; } @@ -157,7 +149,7 @@ return ecd->dev->open(ecd->dev); } -/***************************************************************/ +/*****************************************************************************/ /** Führt die stop()-Funktion des net_devices aus. @@ -169,8 +161,7 @@ int EtherCAT_device_close(EtherCAT_device_t *ecd) { - if (!ecd->dev) - { + if (!ecd->dev) { printk("EtherCAT: No device to close!\n"); return -1; } @@ -182,7 +173,7 @@ return ecd->dev->stop(ecd->dev); } -/***************************************************************/ +/*****************************************************************************/ /** Sendet einen Rahmen über das EtherCAT-Gerät. @@ -206,28 +197,34 @@ unsigned char *frame_data; struct ethhdr *eth; - if (ecd->state == ECAT_DS_SENT) - { - printk(KERN_WARNING "EtherCAT: Trying to send frame while last was not received!\n"); - } - - skb_trim(ecd->tx_skb, 0); // Clear transmit socket buffer - skb_reserve(ecd->tx_skb, ETH_HLEN); // Reserve space for Ethernet-II header + if (unlikely(ecd->state == ECAT_DS_SENT)) { + printk(KERN_WARNING "EtherCAT: Warning - Trying to send frame" + " while last was not received!\n"); + } + + // Clear transmit socket buffer and reserve + // space for Ethernet-II header + skb_trim(ecd->tx_skb, 0); + skb_reserve(ecd->tx_skb, ETH_HLEN); // Copy data to socket buffer frame_data = skb_put(ecd->tx_skb, length); memcpy(frame_data, data, length); // Add Ethernet-II-Header - if ((eth = (struct ethhdr *) skb_push(ecd->tx_skb, ETH_HLEN)) == NULL) - { - printk(KERN_ERR "EtherCAT: device_send - Could not allocate Ethernet-II header!\n"); - return -1; - } - - eth->h_proto = htons(0x88A4); // Protocol type - memcpy(eth->h_source, ecd->dev->dev_addr, ecd->dev->addr_len); // Hardware address - memset(eth->h_dest, 0xFF, ecd->dev->addr_len); // Broadcast address + if (unlikely((eth = (struct ethhdr *) + skb_push(ecd->tx_skb, ETH_HLEN)) == NULL)) { + printk(KERN_ERR "EtherCAT: device_send -" + " Could not allocate Ethernet-II header!\n"); + return -1; + } + + // Protocol type + eth->h_proto = htons(0x88A4); + // Hardware address + memcpy(eth->h_source, ecd->dev->dev_addr, ecd->dev->addr_len); + // Broadcast address + memset(eth->h_dest, 0xFF, ecd->dev->addr_len); rdtscl(ecd->tx_time); // Get CPU cycles @@ -238,14 +235,14 @@ return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Holt einen empfangenen Rahmen von der Netzwerkkarte. Zuerst wird geprüft, ob überhaupt ein Rahmen empfangen - wurde. Wenn ja, wird diesem mit Hilfe eines Spin-Locks - in den angegebenen Speicherbereich kopiert. + wurde. Wenn ja, wird dieser in den angegebenen + Speicherbereich kopiert. @param ecd EtherCAT-Gerät @param data Zeiger auf den Speicherbereich, in den die @@ -257,17 +254,26 @@ int EtherCAT_device_receive(EtherCAT_device_t *ecd, unsigned char *data) { - if (ecd->state != ECAT_DS_RECEIVED) - { - printk(KERN_ERR "EtherCAT: receive - Nothing received!\n"); - return -1; - } - - if (ecd->rx_data_length > ECAT_FRAME_BUFFER_SIZE) - { - printk(KERN_ERR "EtherCAT: receive - Reveived frame too long (%i Bytes)!\n", - ecd->rx_data_length); - return -1; + if (unlikely(ecd->state != ECAT_DS_RECEIVED)) { + if (likely(ecd->error_reported)) { + printk(KERN_ERR "EtherCAT: receive - Nothing received!\n"); + ecd->error_reported = 1; + } + return -1; + } + + if (unlikely(ecd->rx_data_length > ECAT_FRAME_BUFFER_SIZE)) { + if (likely(ecd->error_reported)) { + printk(KERN_ERR "EtherCAT: receive - " + " Reveived frame too long (%i Bytes)!\n", + ecd->rx_data_length); + ecd->error_reported = 1; + } + return -1; + } + + if (unlikely(ecd->error_reported)) { + ecd->error_reported = 0; } memcpy(data, ecd->rx_data, ecd->rx_data_length); @@ -275,7 +281,7 @@ return ecd->rx_data_length; } -/***************************************************************/ +/*****************************************************************************/ /** Ruft manuell die Interrupt-Routine der Netzwerkkarte auf. @@ -287,10 +293,10 @@ void EtherCAT_device_call_isr(EtherCAT_device_t *ecd) { - if (ecd->isr) ecd->isr(0, ecd->dev, NULL); -} - -/***************************************************************/ + if (likely(ecd->isr)) ecd->isr(0, ecd->dev, NULL); +} + +/*****************************************************************************/ /** Gibt alle Informationen über das Device-Objekt aus. @@ -304,16 +310,26 @@ if (ecd) { - printk(KERN_DEBUG "Assigned net_device: %X\n", (unsigned) ecd->dev); - printk(KERN_DEBUG "Transmit socket buffer: %X\n", (unsigned) ecd->tx_skb); - printk(KERN_DEBUG "Receive socket buffer: %X\n", (unsigned) ecd->rx_skb); - printk(KERN_DEBUG "Time of last transmission: %u\n", (unsigned) ecd->tx_time); - printk(KERN_DEBUG "Time of last receive: %u\n", (unsigned) ecd->rx_time); - printk(KERN_DEBUG "Number of transmit interrupts: %u\n", (unsigned) ecd->tx_intr_cnt); - printk(KERN_DEBUG "Number of receive interrupts: %u\n", (unsigned) ecd->rx_intr_cnt); - printk(KERN_DEBUG "Total Number of interrupts: %u\n", (unsigned) ecd->intr_cnt); - printk(KERN_DEBUG "Actual device state: %i\n", (int) ecd->state); - printk(KERN_DEBUG "Receive buffer: %X\n", (unsigned) ecd->rx_data); + printk(KERN_DEBUG "Assigned net_device: %X\n", + (unsigned) ecd->dev); + printk(KERN_DEBUG "Transmit socket buffer: %X\n", + (unsigned) ecd->tx_skb); + printk(KERN_DEBUG "Receive socket buffer: %X\n", + (unsigned) ecd->rx_skb); + printk(KERN_DEBUG "Time of last transmission: %u\n", + (unsigned) ecd->tx_time); + printk(KERN_DEBUG "Time of last receive: %u\n", + (unsigned) ecd->rx_time); + printk(KERN_DEBUG "Number of transmit interrupts: %u\n", + (unsigned) ecd->tx_intr_cnt); + printk(KERN_DEBUG "Number of receive interrupts: %u\n", + (unsigned) ecd->rx_intr_cnt); + printk(KERN_DEBUG "Total Number of interrupts: %u\n", + (unsigned) ecd->intr_cnt); + printk(KERN_DEBUG "Actual device state: %i\n", + (int) ecd->state); + printk(KERN_DEBUG "Receive buffer: %X\n", + (unsigned) ecd->rx_data); printk(KERN_DEBUG "Receive buffer fill state: %u/%u\n", (unsigned) ecd->rx_data_length, ECAT_FRAME_BUFFER_SIZE); } @@ -325,7 +341,7 @@ printk(KERN_DEBUG "---EtherCAT device information end---\n"); } -/***************************************************************/ +/*****************************************************************************/ EXPORT_SYMBOL(EtherCAT_device_init); EXPORT_SYMBOL(EtherCAT_device_clear); @@ -333,4 +349,4 @@ EXPORT_SYMBOL(EtherCAT_device_open); EXPORT_SYMBOL(EtherCAT_device_close); -/***************************************************************/ +/*****************************************************************************/ diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_device.h --- a/drivers/ec_device.h Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_device.h Mon Dec 19 08:13:11 2005 +0000 @@ -1,13 +1,12 @@ -/**************************************************************** +/****************************************************************************** * * e c _ d e v i c e . h * * Struktur für ein EtherCAT-Gerät. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #ifndef _EC_DEVICE_H_ #define _EC_DEVICE_H_ @@ -36,7 +35,7 @@ } EtherCAT_device_state_t; -/***************************************************************/ +/*****************************************************************************/ /** EtherCAT-Gerät. @@ -65,10 +64,12 @@ irqreturn_t (*isr)(int, void *, struct pt_regs *); /**< Adresse der ISR */ struct module *module; /**< Zeiger auf das Modul, das das Gerät zur Verfügung stellt. */ + int error_reported; /**< Zeigt an, ob ein Fehler im zyklischen Code + bereits gemeldet wurde. */ } EtherCAT_device_t; -/***************************************************************/ +/*****************************************************************************/ void EtherCAT_device_init(EtherCAT_device_t *); int EtherCAT_device_assign(EtherCAT_device_t *, struct net_device *); @@ -83,6 +84,6 @@ void EtherCAT_device_debug(EtherCAT_device_t *); -/***************************************************************/ +/*****************************************************************************/ #endif diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_globals.h --- a/drivers/ec_globals.h Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_globals.h Mon Dec 19 08:13:11 2005 +0000 @@ -1,13 +1,12 @@ -/**************************************************************** +/****************************************************************************** * * e c _ g l o b a l s . h * * Globale Definitionen und Makros für das EtherCAT-Protokoll. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #ifndef _EC_GLOBALS_ #define _EC_GLOBALS_ @@ -62,6 +61,6 @@ } EtherCAT_state_t; -/***************************************************************/ +/*****************************************************************************/ #endif diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_master.c --- a/drivers/ec_master.c Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_master.c Mon Dec 19 08:13:11 2005 +0000 @@ -1,13 +1,12 @@ -/**************************************************************** +/****************************************************************************** * * e c _ m a s t e r . c * * Methoden für einen EtherCAT-Master. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #include #include @@ -18,13 +17,13 @@ #include "ec_globals.h" #include "ec_master.h" -/***************************************************************/ +/*****************************************************************************/ /** Konstruktor des EtherCAT-Masters. @param master Zeiger auf den zu initialisierenden - EtherCAT-Master + EtherCAT-Master @return 0 bei Erfolg, sonst < 0 (= dev ist NULL) */ @@ -41,7 +40,7 @@ master->debug_level = 0; } -/***************************************************************/ +/*****************************************************************************/ /** Destruktor eines EtherCAT-Masters. @@ -57,8 +56,7 @@ // Remove all slaves EtherCAT_clear_slaves(master); - if (master->process_data) - { + if (master->process_data) { kfree(master->process_data); master->process_data = NULL; } @@ -66,7 +64,7 @@ master->process_data_length = 0; } -/***************************************************************/ +/*****************************************************************************/ /** Öffnet ein EtherCAT-Geraet für den Master. @@ -76,27 +74,26 @@ @param master Der EtherCAT-Master @param device Das EtherCAT-Geraet @return 0, wenn alles o.k., - < 0, wenn bereits ein Geraet registriert - oder das Geraet nicht geoeffnet werden konnte. + < 0, wenn bereits ein Geraet registriert + oder das Geraet nicht geoeffnet werden konnte. */ int EtherCAT_master_open(EtherCAT_master_t *master, EtherCAT_device_t *device) { - if (!master || !device) - { - printk(KERN_ERR "EtherCAT: Illegal parameters for master_open()!\n"); - return -1; - } - - if (master->dev) - { - printk(KERN_ERR "EtherCAT: Master already has a device.\n"); - return -1; - } - - if (EtherCAT_device_open(device) < 0) - { + if (!master || !device) { + printk(KERN_ERR "EtherCAT: Illegal parameters" + " for master_open()!\n"); + return -1; + } + + if (master->dev) { + printk(KERN_ERR "EtherCAT: Master already" + " has a device.\n"); + return -1; + } + + if (EtherCAT_device_open(device) < 0) { printk(KERN_ERR "EtherCAT: Could not open device %X!\n", (unsigned int) master->dev); return -1; @@ -107,7 +104,7 @@ return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Schliesst das EtherCAT-Geraet, auf dem der Master arbeitet. @@ -119,21 +116,21 @@ void EtherCAT_master_close(EtherCAT_master_t *master, EtherCAT_device_t *device) { - if (master->dev != device) - { - printk(KERN_WARNING "EtherCAT: Trying to close an unknown device!\n"); + if (master->dev != device) { + printk(KERN_WARNING "EtherCAT: Warning -" + " Trying to close an unknown device!\n"); return; } - if (EtherCAT_device_close(master->dev) < 0) - { - printk(KERN_WARNING "EtherCAT: Could not close device!\n"); + if (EtherCAT_device_close(master->dev) < 0) { + printk(KERN_WARNING "EtherCAT: Warning -" + " Could not close device!\n"); } master->dev = NULL; } -/***************************************************************/ +/*****************************************************************************/ /** Sendet ein einzelnes Kommando in einem Frame und @@ -150,26 +147,28 @@ { unsigned int tries_left; - if (EtherCAT_simple_send(master, cmd) < 0) return -1; + if (unlikely(EtherCAT_simple_send(master, cmd) < 0)) + return -1; udelay(3); EtherCAT_device_call_isr(master->dev); tries_left = 20; - while (master->dev->state == ECAT_DS_SENT && tries_left) - { + while (unlikely(master->dev->state == ECAT_DS_SENT + && tries_left)) { udelay(1); EtherCAT_device_call_isr(master->dev); tries_left--; } - if (EtherCAT_simple_receive(master, cmd) < 0) return -1; + if (unlikely(EtherCAT_simple_receive(master, cmd) < 0)) + return -1; return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Sendet ein einzelnes Kommando in einem Frame. @@ -185,29 +184,27 @@ { unsigned int length, framelength, i; - if (master->debug_level > 0) - { + if (unlikely(master->debug_level > 0)) { printk(KERN_DEBUG "EtherCAT_send_receive_command\n"); } - if (cmd->state != ECAT_CS_READY) - { - printk(KERN_WARNING "EtherCAT_send_receive_command: Command not in ready state!\n"); + if (unlikely(cmd->state != ECAT_CS_READY)) { + printk(KERN_WARNING "EtherCAT_send_receive_command:" + "Command not in ready state!\n"); } length = cmd->data_length + 12; framelength = length + 2; - if (framelength > ECAT_FRAME_BUFFER_SIZE) - { - printk(KERN_ERR "EtherCAT: Frame too long (%i)!\n", framelength); + if (unlikely(framelength > ECAT_FRAME_BUFFER_SIZE)) { + printk(KERN_ERR "EtherCAT: Frame too long (%i)!\n", + framelength); return -1; } if (framelength < 46) framelength = 46; - if (master->debug_level > 0) - { + if (unlikely(master->debug_level > 0)) { printk(KERN_DEBUG "Frame length: %i\n", framelength); } @@ -217,8 +214,7 @@ cmd->index = master->command_index; master->command_index = (master->command_index + 1) % 0x0100; - if (master->debug_level > 0) - { + if (unlikely(master->debug_level > 0)) { printk(KERN_DEBUG "Sending command index %i\n", cmd->index); } @@ -235,14 +231,15 @@ master->tx_data[2 + 8] = 0x00; master->tx_data[2 + 9] = 0x00; - if (cmd->type == ECAT_CMD_APWR - || cmd->type == ECAT_CMD_NPWR - || cmd->type == ECAT_CMD_BWR - || cmd->type == ECAT_CMD_LRW) // Write - { - for (i = 0; i < cmd->data_length; i++) master->tx_data[2 + 10 + i] = cmd->data[i]; - } - else // Read + if (likely(cmd->type == ECAT_CMD_APWR + || cmd->type == ECAT_CMD_NPWR + || cmd->type == ECAT_CMD_BWR + || cmd->type == ECAT_CMD_LRW)) // Write commands + { + for (i = 0; i < cmd->data_length; i++) + master->tx_data[2 + 10 + i] = cmd->data[i]; + } + else // Read commands { for (i = 0; i < cmd->data_length; i++) master->tx_data[2 + 10 + i] = 0x00; } @@ -255,27 +252,26 @@ master->tx_data_length = framelength; - if (master->debug_level > 0) - { + if (unlikely(master->debug_level > 0)) { printk(KERN_DEBUG "device send...\n"); } // Send frame - if (EtherCAT_device_send(master->dev, master->tx_data, framelength) != 0) - { + if (unlikely(EtherCAT_device_send(master->dev, + master->tx_data, + framelength) != 0)) { printk(KERN_ERR "EtherCAT: Could not send!\n"); return -1; } - if (master->debug_level > 0) - { + if (unlikely(master->debug_level > 0)) { printk(KERN_DEBUG "EtherCAT_send done.\n"); } return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Wartet auf den Empfang eines einzeln gesendeten @@ -291,49 +287,49 @@ EtherCAT_command_t *cmd) { unsigned int length; - int receive_ret; + int ret; unsigned char command_type, command_index; - if ((receive_ret = EtherCAT_device_receive(master->dev, - master->rx_data)) < 0) - { - return -1; - } - - master->rx_data_length = (unsigned int) receive_ret; - - if (master->rx_data_length < 2) - { - printk(KERN_ERR "EtherCAT: Received frame with incomplete EtherCAT header!\n"); + if (unlikely((ret = EtherCAT_device_receive(master->dev, + master->rx_data)) < 0)) + return -1; + + master->rx_data_length = (unsigned int) ret; + + if (unlikely(master->rx_data_length < 2)) { + printk(KERN_ERR "EtherCAT: Received frame with" + " incomplete EtherCAT header!\n"); output_debug_data(master); return -1; } // Länge des gesamten Frames prüfen - length = ((master->rx_data[1] & 0x07) << 8) | (master->rx_data[0] & 0xFF); - - if (length > master->rx_data_length) - { - printk(KERN_ERR "EtherCAT: Received corrupted frame (length does not match)!\n"); + length = ((master->rx_data[1] & 0x07) << 8) + | (master->rx_data[0] & 0xFF); + + if (unlikely(length > master->rx_data_length)) { + printk(KERN_ERR "EtherCAT: Received corrupted" + " frame (length does not match)!\n"); output_debug_data(master); return -1; } command_type = master->rx_data[2]; command_index = master->rx_data[2 + 1]; - length = (master->rx_data[2 + 6] & 0xFF) | ((master->rx_data[2 + 7] & 0x07) << 8); - - if (master->rx_data_length - 2 < length + 12) - { - printk(KERN_ERR "EtherCAT: Received frame with incomplete command data!\n"); + length = (master->rx_data[2 + 6] & 0xFF) + | ((master->rx_data[2 + 7] & 0x07) << 8); + + if (unlikely(master->rx_data_length - 2 < length + 12)) { + printk(KERN_ERR "EtherCAT: Received frame with" + " incomplete command data!\n"); output_debug_data(master); return -1; } - if (cmd->state == ECAT_CS_SENT - && cmd->type == command_type - && cmd->index == command_index - && cmd->data_length == length) + if (likely(cmd->state == ECAT_CS_SENT + && cmd->type == command_type + && cmd->index == command_index + && cmd->data_length == length)) { cmd->state = ECAT_CS_RECEIVED; @@ -355,7 +351,7 @@ return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Überprüft die angeschlossenen Slaves. @@ -381,8 +377,7 @@ unsigned int i, j, found, length, pos; unsigned char data[2]; - if (slave_count == 0) - { + if (unlikely(!slave_count)) { printk(KERN_ERR "EtherCAT: No slaves in list!\n"); return -1; } @@ -391,27 +386,25 @@ EtherCAT_command_broadcast_read(&cmd, 0x0000, 4); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != slave_count) - { + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != slave_count)) { printk(KERN_ERR "EtherCAT: Wrong number of slaves on bus: %i / %i\n", cmd.working_counter, slave_count); return -1; } else - { printk("EtherCAT: Found all %i slaves.\n", slave_count); - } // For every slave in the list for (i = 0; i < slave_count; i++) { cur = &slaves[i]; - if (!cur->desc) - { - printk(KERN_ERR "EtherCAT: Slave %i has no description.\n", i); + if (unlikely(!cur->desc)) { + printk(KERN_ERR "EtherCAT: Slave %i has" + " no description.\n", i); return -1; } @@ -424,23 +417,28 @@ data[0] = cur->station_address & 0x00FF; data[1] = (cur->station_address & 0xFF00) >> 8; - EtherCAT_command_position_write(&cmd, cur->ring_position, 0x0010, 2, data); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Slave %i did not repond while writing station address!\n", i); + EtherCAT_command_position_write(&cmd, cur->ring_position, + 0x0010, 2, data); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Slave %i did not repond" + " while writing station address!\n", i); return -1; } // Read base data EtherCAT_command_read(&cmd, cur->station_address, 0x0000, 4); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Slave %i did not respond while reading base data!\n", i); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Slave %i did not respond" + " while reading base data!\n", i); return -1; } @@ -451,29 +449,37 @@ // Read identification from "Slave Information Interface" (SII) - if (EtherCAT_read_slave_information(master, cur->station_address, - 0x0008, &cur->vendor_id) != 0) + if (unlikely(EtherCAT_read_slave_information(master, + cur->station_address, + 0x0008, + &cur->vendor_id) != 0)) { printk(KERN_ERR "EtherCAT: Could not read SII vendor id!\n"); return -1; } - if (EtherCAT_read_slave_information(master, cur->station_address, - 0x000A, &cur->product_code) != 0) + if (unlikely(EtherCAT_read_slave_information(master, + cur->station_address, + 0x000A, + &cur->product_code) != 0)) { printk(KERN_ERR "EtherCAT: Could not read SII product code!\n"); return -1; } - if (EtherCAT_read_slave_information(master, cur->station_address, - 0x000C, &cur->revision_number) != 0) + if (unlikely(EtherCAT_read_slave_information(master, + cur->station_address, + 0x000C, + &cur->revision_number) != 0)) { printk(KERN_ERR "EtherCAT: Could not read SII revision number!\n"); return -1; } - if (EtherCAT_read_slave_information(master, cur->station_address, - 0x000E, &cur->serial_number) != 0) + if (unlikely(EtherCAT_read_slave_information(master, + cur->station_address, + 0x000E, + &cur->serial_number) != 0)) { printk(KERN_ERR "EtherCAT: Could not read SII serial number!\n"); return -1; @@ -483,17 +489,16 @@ found = 0; - for (j = 0; j < slave_idents_count; j++) + for (j = 0; j < slave_ident_count; j++) { - if (slave_idents[j].vendor_id == cur->vendor_id - && slave_idents[j].product_code == cur->product_code) + if (unlikely(slave_idents[j].vendor_id == cur->vendor_id + && slave_idents[j].product_code == cur->product_code)) { found = 1; - if (cur->desc != slave_idents[j].desc) - { - printk(KERN_ERR "EtherCAT: Unexpected slave device \"%s %s\"" - " at position %i. Expected: \"%s %s\"\n", + if (unlikely(cur->desc != slave_idents[j].desc)) { + printk(KERN_ERR "EtherCAT: Unexpected slave device" + " \"%s %s\" at position %i. Expected: \"%s %s\"\n", slave_idents[j].desc->vendor_name, slave_idents[j].desc->product_name, i, cur->desc->vendor_name, cur->desc->product_name); @@ -504,8 +509,7 @@ } } - if (!found) - { + if (unlikely(!found)) { printk(KERN_ERR "EtherCAT: Unknown slave device" " (vendor %X, code %X) at position %i.\n", cur->vendor_id, cur->product_code, i); @@ -519,10 +523,11 @@ length += slaves[i].desc->data_length; } - if ((master->process_data = (unsigned char *) - kmalloc(sizeof(unsigned char) * length, GFP_KERNEL)) == NULL) - { - printk(KERN_ERR "EtherCAT: Could not allocate %i bytes for process data.\n", length); + if (unlikely((master->process_data = (unsigned char *) + kmalloc(sizeof(unsigned char) + * length, GFP_KERNEL)) == NULL)) { + printk(KERN_ERR "EtherCAT: Could not allocate %i" + " bytes for process data.\n", length); return -1; } @@ -535,8 +540,10 @@ slaves[i].process_data = master->process_data + pos; slaves[i].logical_address0 = pos; - printk(KERN_DEBUG "EtherCAT: Slave %i - Address 0x%X, \"%s %s\", s/n %u\n", - i, pos, slaves[i].desc->vendor_name, slaves[i].desc->product_name, + printk(KERN_DEBUG "EtherCAT: Slave %i -" + " Address 0x%X, \"%s %s\", s/n %u\n", + i, pos, slaves[i].desc->vendor_name, + slaves[i].desc->product_name, slaves[i].serial_number); pos += slaves[i].desc->data_length; @@ -548,7 +555,7 @@ return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Entfernt den Zeiger auf das Slave-Array. @@ -562,7 +569,7 @@ master->slave_count = 0; } -/***************************************************************/ +/*****************************************************************************/ /** Liest Daten aus dem Slave-Information-Interface @@ -596,12 +603,13 @@ data[5] = 0x00; EtherCAT_command_write(&cmd, node_address, 0x502, 6, data); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -3; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: SII-read - Slave %04X did not respond!\n", - node_address); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -3; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: SII-read - Slave" + " %04X did not respond!\n", node_address); return -4; } @@ -610,22 +618,22 @@ // den Status auslesen, bis das Bit weg ist. tries_left = 100; - while (tries_left) + while (likely(tries_left)) { udelay(10); EtherCAT_command_read(&cmd, node_address, 0x502, 10); - if (EtherCAT_simple_send_receive(master, &cmd) != 0) return -3; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: SII-read status - Slave %04X did not respond!\n", - node_address); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) != 0)) + return -3; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: SII-read status -" + " Slave %04X did not respond!\n", node_address); return -4; } - if ((cmd.data[1] & 0x81) == 0) - { + if (likely((cmd.data[1] & 0x81) == 0)) { memcpy(target, cmd.data + 6, 4); break; } @@ -633,17 +641,16 @@ tries_left--; } - if (!tries_left) - { - printk(KERN_WARNING "EtherCAT: SSI-read. Slave %04X timed out!\n", - node_address); + if (unlikely(!tries_left)) { + printk(KERN_WARNING "EtherCAT: SSI-read." + " Slave %04X timed out!\n", node_address); return -1; } return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Ändert den Zustand eines Slaves (asynchron). @@ -669,62 +676,63 @@ data[0] = state_and_ack; data[1] = 0x00; - EtherCAT_command_write(&cmd, slave->station_address, 0x0120, 2, data); - - if (EtherCAT_simple_send_receive(master, &cmd) != 0) - { - printk(KERN_ERR "EtherCAT: Could not set state %02X - Unable to send!\n", state_and_ack); + EtherCAT_command_write(&cmd, slave->station_address, + 0x0120, 2, data); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) != 0)) { + printk(KERN_ERR "EtherCAT: Could not set state %02X -" + " Unable to send!\n", state_and_ack); return -2; } - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Could not set state %02X - Device \"%s %s\" (%d) did not respond!\n", - state_and_ack, - slave->desc->vendor_name, - slave->desc->product_name, - slave->ring_position*(-1)); + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Could not set state %02X -" + " Device \"%s %s\" (%d) did not respond!\n", + state_and_ack, slave->desc->vendor_name, + slave->desc->product_name, slave->ring_position*(-1)); return -3; } slave->requested_state = state_and_ack & 0x0F; tries_left = 100; - while (tries_left) + while (likely(tries_left)) { udelay(10); EtherCAT_command_read(&cmd, slave->station_address, 0x0130, 2); - if (EtherCAT_simple_send_receive(master, &cmd) != 0) - { - printk(KERN_ERR "EtherCAT: Could not check state %02X - Unable to send!\n", state_and_ack); + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) != 0)) { + printk(KERN_ERR "EtherCAT: Could not check" + " state %02X - Unable to send!\n", state_and_ack); return -2; } - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Could not check state %02X - Device did not respond!\n", state_and_ack); + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Could not check" + " state %02X - Device did not respond!\n", + state_and_ack); return -3; } - if (cmd.data[0] & 0x10) // State change error - { - printk(KERN_ERR "EtherCAT: Could not set state %02X - Device refused state change (code %02X)!\n", state_and_ack, cmd.data[0]); + if (unlikely(cmd.data[0] & 0x10)) { // State change error + printk(KERN_ERR "EtherCAT: Could not set state %02X -" + " Device refused state change (code %02X)!\n", + state_and_ack, cmd.data[0]); return -4; } - if (cmd.data[0] == (state_and_ack & 0x0F)) // State change successful - { + if (likely(cmd.data[0] == (state_and_ack & 0x0F))) { + // State change successful break; } tries_left--; } - if (!tries_left) - { - printk(KERN_ERR "EtherCAT: Could not check state %02X - Timeout while checking!\n", state_and_ack); + if (unlikely(!tries_left)) { + printk(KERN_ERR "EtherCAT: Could not check state %02X -" + " Timeout while checking!\n", state_and_ack); return -5; } @@ -733,7 +741,7 @@ return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Konfiguriert einen Slave und setzt den Operational-Zustand. @@ -758,22 +766,23 @@ desc = slave->desc; - if (EtherCAT_state_change(master, slave, ECAT_STATE_INIT) != 0) - { - return -1; - } + if (unlikely(EtherCAT_state_change(master, slave, + ECAT_STATE_INIT) != 0)) + return -1; // Resetting FMMU's memset(data, 0x00, 256); - EtherCAT_command_write(&cmd, slave->station_address, 0x0600, 256, data); - - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Resetting FMMUs - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0600, 256, data); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Resetting FMMUs -" + " Slave %04X did not respond!\n", slave->station_address); return -2; } @@ -784,12 +793,15 @@ { memset(data, 0x00, 256); - EtherCAT_command_write(&cmd, slave->station_address, 0x0800, 256, data); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Resetting SMs - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0800, 256, data); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Resetting SMs -" + " Slave %04X did not respond!\n", slave->station_address); return -2; } @@ -801,12 +813,15 @@ { if (desc->sm0) { - EtherCAT_command_write(&cmd, slave->station_address, 0x0800, 8, desc->sm0); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Setting SM0 - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0800, 8, desc->sm0); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Setting SM0 -" + " Slave %04X did not respond!\n", slave->station_address); return -3; } @@ -814,12 +829,15 @@ if (desc->sm1) { - EtherCAT_command_write(&cmd, slave->station_address, 0x0808, 8, desc->sm1); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Setting SM1 - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0808, 8, desc->sm1); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Setting SM1 -" + " Slave %04X did not respond!\n", slave->station_address); return -2; } @@ -828,10 +846,9 @@ // Change state to PREOP - if (EtherCAT_state_change(master, slave, ECAT_STATE_PREOP) != 0) - { + if (unlikely(EtherCAT_state_change(master, slave, + ECAT_STATE_PREOP) != 0)) return -5; - } // Set FMMU's @@ -844,12 +861,15 @@ fmmu[2] = (slave->logical_address0 & 0x00FF0000) >> 16; fmmu[3] = (slave->logical_address0 & 0xFF000000) >> 24; - EtherCAT_command_write(&cmd, slave->station_address, 0x0600, 16, fmmu); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Setting FMMU0 - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0600, 16, fmmu); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Setting FMMU0 -" + " Slave %04X did not respond!\n", slave->station_address); return -2; } @@ -861,12 +881,15 @@ { if (desc->sm0) { - EtherCAT_command_write(&cmd, slave->station_address, 0x0800, 8, desc->sm0); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Setting SM0 - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0800, 8, desc->sm0); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Setting SM0 -" + " Slave %04X did not respond!\n", slave->station_address); return -3; } @@ -874,12 +897,15 @@ if (desc->sm1) { - EtherCAT_command_write(&cmd, slave->station_address, 0x0808, 8, desc->sm1); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Setting SM1 - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0808, 8, desc->sm1); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Setting SM1 -" + " Slave %04X did not respond!\n", slave->station_address); return -3; } @@ -888,12 +914,15 @@ if (desc->sm2) { - EtherCAT_command_write(&cmd, slave->station_address, 0x0810, 8, desc->sm2); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Setting SM2 - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0810, 8, desc->sm2); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Setting SM2 -" + " Slave %04X did not respond!\n", slave->station_address); return -3; } @@ -901,33 +930,34 @@ if (desc->sm3) { - EtherCAT_command_write(&cmd, slave->station_address, 0x0818, 8, desc->sm3); - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != 1) - { - printk(KERN_ERR "EtherCAT: Setting SM3 - Slave %04X did not respond!\n", + EtherCAT_command_write(&cmd, slave->station_address, + 0x0818, 8, desc->sm3); + + if (unlikely(EtherCAT_simple_send_receive(master, &cmd) < 0)) + return -1; + + if (unlikely(cmd.working_counter != 1)) { + printk(KERN_ERR "EtherCAT: Setting SM3 -" + " Slave %04X did not respond!\n", slave->station_address); return -3; } } // Change state to SAVEOP - if (EtherCAT_state_change(master, slave, ECAT_STATE_SAVEOP) != 0) - { + if (unlikely(EtherCAT_state_change(master, slave, + ECAT_STATE_SAVEOP) != 0)) return -12; - } // Change state to OP - if (EtherCAT_state_change(master, slave, ECAT_STATE_OP) != 0) - { + if (unlikely(EtherCAT_state_change(master, slave, + ECAT_STATE_OP) != 0)) return -13; - } return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Setzt einen Slave zurück in den Init-Zustand. @@ -939,17 +969,16 @@ */ int EtherCAT_deactivate_slave(EtherCAT_master_t *master, - EtherCAT_slave_t *slave) -{ - if (EtherCAT_state_change(master, slave, ECAT_STATE_INIT) != 0) - { - return -1; - } + EtherCAT_slave_t *slave) +{ + if (unlikely(EtherCAT_state_change(master, slave, + ECAT_STATE_INIT) != 0)) + return -1; return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Aktiviert alle Slaves. @@ -967,16 +996,15 @@ for (i = 0; i < master->slave_count; i++) { - if (EtherCAT_activate_slave(master, &master->slaves[i]) < 0) - { - return -1; - } + if (unlikely(EtherCAT_activate_slave(master, + &master->slaves[i]) < 0)) + return -1; } return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Deaktiviert alle Slaves. @@ -995,16 +1023,15 @@ for (i = 0; i < master->slave_count; i++) { - if (EtherCAT_deactivate_slave(master, &master->slaves[i]) < 0) - { + if (unlikely(EtherCAT_deactivate_slave(master, + &master->slaves[i]) < 0)) ret = -1; - } } return ret; } -/***************************************************************/ +/*****************************************************************************/ /** Sendet alle Prozessdaten an die Slaves. @@ -1023,16 +1050,18 @@ 0, master->process_data_length, master->process_data); - if (EtherCAT_simple_send(master, &master->process_data_command) < 0) - { - printk(KERN_ERR "EtherCAT: Could not send process data command!\n"); + if (unlikely(EtherCAT_simple_send(master, + &master->process_data_command) < 0)) + { + printk(KERN_ERR "EtherCAT: Could not send" + " process data command!\n"); return -1; } return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Empfängt alle Prozessdaten von den Slaves. @@ -1053,26 +1082,28 @@ EtherCAT_device_call_isr(master->dev); tries_left = 20; - while (master->dev->state == ECAT_DS_SENT && tries_left) + while (unlikely(master->dev->state == ECAT_DS_SENT + && tries_left)) { udelay(1); EtherCAT_device_call_isr(master->dev); tries_left--; } - if (!tries_left) + if (unlikely(!tries_left)) { printk(KERN_ERR "EtherCAT: Timeout while receiving process data!\n"); return -1; } - if (EtherCAT_simple_receive(master, &master->process_data_command) < 0) + if (unlikely(EtherCAT_simple_receive(master, + &master->process_data_command) < 0)) { printk(KERN_ERR "EtherCAT: Could not receive cyclic command!\n"); return -1; } - if (master->process_data_command.state != ECAT_CS_RECEIVED) + if (unlikely(master->process_data_command.state != ECAT_CS_RECEIVED)) { printk(KERN_WARNING "EtherCAT: Process data command not received!\n"); return -1; @@ -1085,7 +1116,7 @@ return 0; } -/***************************************************************/ +/*****************************************************************************/ /** Verwirft das zuletzt gesendete Prozessdatenkommando. @@ -1099,7 +1130,7 @@ master->dev->state = ECAT_DS_READY; } -/***************************************************************/ +/*****************************************************************************/ /** Gibt Frame-Inhalte zwecks Debugging aus. @@ -1134,7 +1165,7 @@ printk("\n"); } -/***************************************************************/ +/*****************************************************************************/ EXPORT_SYMBOL(EtherCAT_master_init); EXPORT_SYMBOL(EtherCAT_master_clear); @@ -1147,4 +1178,4 @@ EXPORT_SYMBOL(EtherCAT_clear_process_data); EXPORT_SYMBOL(EtherCAT_deactivate_all_slaves); -/***************************************************************/ +/*****************************************************************************/ diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_master.h --- a/drivers/ec_master.h Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_master.h Mon Dec 19 08:13:11 2005 +0000 @@ -1,13 +1,12 @@ -/**************************************************************** +/****************************************************************************** * * e c _ m a s t e r . h * * Struktur für einen EtherCAT-Master. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #ifndef _EC_MASTER_H_ #define _EC_MASTER_H_ @@ -16,7 +15,7 @@ #include "ec_slave.h" #include "ec_command.h" -/***************************************************************/ +/*****************************************************************************/ /** EtherCAT-Master @@ -53,7 +52,7 @@ } EtherCAT_master_t; -/***************************************************************/ +/*****************************************************************************/ // Master creation and deletion void EtherCAT_master_init(EtherCAT_master_t *); @@ -89,6 +88,6 @@ // Private functions void output_debug_data(const EtherCAT_master_t *); -/***************************************************************/ +/*****************************************************************************/ #endif diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_module.c --- a/drivers/ec_module.c Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_module.c Mon Dec 19 08:13:11 2005 +0000 @@ -16,7 +16,7 @@ * Fax.: +49 201/61 98 36 * E-mail: sp@igh-essen.com * - ******************************************************************************/ + *****************************************************************************/ #include #include @@ -24,30 +24,32 @@ #include "ec_module.h" -/******************************************************************************/ - -#define LITERAL(X) #X -#define STRINGIFY(X) LITERAL(X) - -#define COMPILE_INFO "Revision " STRINGIFY(EC_REV) \ - ", compiled by " STRINGIFY(EC_USER) \ - " at " STRINGIFY(EC_DATE) - -/******************************************************************************/ +/*****************************************************************************/ + +#define LIT(X) #X +#define STR(X) LIT(X) + +#define COMPILE_INFO "Revision " STR(EC_REV) \ + ", compiled by " STR(EC_USER) \ + " at " STR(EC_DATE) + +/*****************************************************************************/ int ecat_master_count = 1; EtherCAT_master_t *ecat_masters = NULL; int *ecat_masters_reserved = NULL; -/******************************************************************************/ - -MODULE_AUTHOR ("Wilhelm Hagemeister , Florian Pose "); +/*****************************************************************************/ + +MODULE_AUTHOR ("Wilhelm Hagemeister ," + "Florian Pose "); MODULE_DESCRIPTION ("EtherCAT master driver module"); MODULE_LICENSE("GPL"); MODULE_VERSION(COMPILE_INFO); module_param(ecat_master_count, int, 1); -MODULE_PARM_DESC(ecat_master_count, "Number of EtherCAT master to initialize."); +MODULE_PARM_DESC(ecat_master_count, + "Number of EtherCAT master to initialize."); module_init(ecat_init_module); module_exit(ecat_cleanup_module); @@ -57,7 +59,7 @@ EXPORT_SYMBOL(EtherCAT_request); EXPORT_SYMBOL(EtherCAT_release); -/******************************************************************************/ +/*****************************************************************************/ /** Init-Funktion des EtherCAT-Master-Treibermodules @@ -75,28 +77,29 @@ printk(KERN_ERR "EtherCAT: Master driver, %s\n", COMPILE_INFO); - if (ecat_master_count < 1) - { - printk(KERN_ERR "EtherCAT: Error - Illegal ecat_master_count: %i\n", - ecat_master_count); + if (ecat_master_count < 1) { + printk(KERN_ERR "EtherCAT: Error - Illegal" + " ecat_master_count: %i\n", ecat_master_count); return -1; } printk(KERN_ERR "EtherCAT: Initializing %i EtherCAT master(s)...\n", ecat_master_count); - if ((ecat_masters = (EtherCAT_master_t *) kmalloc(sizeof(EtherCAT_master_t) - * ecat_master_count, - GFP_KERNEL)) == NULL) - { - printk(KERN_ERR "EtherCAT: Could not allocate memory for EtherCAT master(s)!\n"); - return -1; - } - - if ((ecat_masters_reserved = (int *) kmalloc(sizeof(int) * ecat_master_count, - GFP_KERNEL)) == NULL) - { - printk(KERN_ERR "EtherCAT: Could not allocate memory for reservation flags!\n"); + if ((ecat_masters = + (EtherCAT_master_t *) kmalloc(sizeof(EtherCAT_master_t) + * ecat_master_count, + GFP_KERNEL)) == NULL) { + printk(KERN_ERR "EtherCAT: Could not allocate" + " memory for EtherCAT master(s)!\n"); + return -1; + } + + if ((ecat_masters_reserved = + (int *) kmalloc(sizeof(int) * ecat_master_count, + GFP_KERNEL)) == NULL) { + printk(KERN_ERR "EtherCAT: Could not allocate" + " memory for reservation flags!\n"); kfree(ecat_masters); return -1; } @@ -112,7 +115,7 @@ return 0; } -/******************************************************************************/ +/*****************************************************************************/ /** Cleanup-Funktion des EtherCAT-Master-Treibermoduls @@ -131,7 +134,8 @@ for (i = 0; i < ecat_master_count; i++) { if (ecat_masters_reserved[i]) { - printk(KERN_WARNING "EtherCAT: Warning - Master %i is still in use!\n", i); + printk(KERN_WARNING "EtherCAT: Warning -" + " Master %i is still in use!\n", i); } EtherCAT_master_clear(&ecat_masters[i]); @@ -143,7 +147,7 @@ printk(KERN_ERR "EtherCAT: Master driver cleaned up.\n"); } -/***************************************************************/ +/*****************************************************************************/ /** Setzt das EtherCAT-Geraet, auf dem der Master arbeitet. @@ -159,8 +163,7 @@ int EtherCAT_register_device(int index, EtherCAT_device_t *device) { - if (index < 0 || index >= ecat_master_count) - { + if (index < 0 || index >= ecat_master_count) { printk(KERN_ERR "EtherCAT: Master %i does not exist!\n", index); return -1; } @@ -168,7 +171,7 @@ return EtherCAT_master_open(&ecat_masters[index], device); } -/***************************************************************/ +/*****************************************************************************/ /** Loescht das EtherCAT-Geraet, auf dem der Master arbeitet. @@ -179,8 +182,7 @@ void EtherCAT_unregister_device(int index, EtherCAT_device_t *device) { - if (index < 0 || index >= ecat_master_count) - { + if (index < 0 || index >= ecat_master_count) { printk(KERN_WARNING "EtherCAT: Master %i does not exist!\n", index); return; } @@ -188,7 +190,7 @@ EtherCAT_master_close(&ecat_masters[index], device); } -/******************************************************************************/ +/*****************************************************************************/ /** Reserviert einen bestimmten EtherCAT-Master und das zugehörige Gerät. @@ -212,7 +214,8 @@ } if (!ecat_masters[index].dev) { - printk(KERN_ERR "EtherCAT: Master %i has no device assigned yet!\n", index); + printk(KERN_ERR "EtherCAT: Master %i has no device assigned yet!\n", + index); return NULL; } @@ -233,7 +236,7 @@ return &ecat_masters[index]; } -/******************************************************************************/ +/*****************************************************************************/ /** Gibt einen zuvor reservierten EtherCAT-Master wieder frei. @@ -268,4 +271,4 @@ (unsigned int) master); } -/******************************************************************************/ +/*****************************************************************************/ diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_module.h --- a/drivers/ec_module.h Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_module.h Mon Dec 19 08:13:11 2005 +0000 @@ -16,7 +16,7 @@ * Fax.: +49 201/61 98 36 * E-mail: sp@igh-essen.com * - ******************************************************************************/ + *****************************************************************************/ #include #include @@ -24,7 +24,7 @@ #include "ec_master.h" -/******************************************************************************/ +/*****************************************************************************/ int __init ecat_init_module(void); void __exit ecat_cleanup_module(void); @@ -36,4 +36,4 @@ EtherCAT_master_t *EtherCAT_request(int); void EtherCAT_release(EtherCAT_master_t *); -/******************************************************************************/ +/*****************************************************************************/ diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_slave.c --- a/drivers/ec_slave.c Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_slave.c Mon Dec 19 08:13:11 2005 +0000 @@ -1,20 +1,19 @@ -/**************************************************************** +/****************************************************************************** * * e c _ s l a v e . c * * Methoden für einen EtherCAT-Slave. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #include #include "ec_globals.h" #include "ec_slave.h" -/***************************************************************/ +/*****************************************************************************/ /** EtherCAT-Slave-Konstruktor. @@ -29,24 +28,20 @@ slave->type = 0; slave->revision = 0; slave->build = 0; - slave->ring_position = 0; slave->station_address = 0; - slave->vendor_id = 0; slave->product_code = 0; slave->revision_number = 0; slave->serial_number = 0; - - slave->desc = 0; - + slave->desc = NULL; slave->logical_address0 = 0; - slave->current_state = ECAT_STATE_UNKNOWN; slave->requested_state = ECAT_STATE_UNKNOWN; + slave->error_reported = 0; } -/***************************************************************/ +/*****************************************************************************/ /** EtherCAT-Slave-Destruktor. @@ -61,7 +56,7 @@ // Nothing yet... } -/***************************************************************/ +/*****************************************************************************/ /** Liest einen bestimmten Kanal des Slaves als Integer-Wert. @@ -81,37 +76,46 @@ int EtherCAT_read_value(EtherCAT_slave_t *slave, unsigned int channel) { - if (!slave->desc) - { - printk(KERN_WARNING "EtherCAT: Reading failed on slave %04X (addr %0X)" - " - Slave has no description.\n", - slave->station_address, (unsigned int) slave); + if (unlikely(!slave->desc)) { + if (likely(slave->error_reported)) { + printk(KERN_WARNING "EtherCAT: Reading failed on slave %04X (addr %0X)" + " - Slave has no description.\n", + slave->station_address, (unsigned int) slave); + slave->error_reported = 1; + } return 0; } - if (!slave->desc->read) - { - printk(KERN_WARNING "EtherCAT: Reading failed on slave %04X (addr %0X)" - " - Slave type (%s %s) has no read method.\n", - slave->station_address, (unsigned int) slave, - slave->desc->vendor_name, slave->desc->product_name); + if (unlikely(!slave->desc->read)) { + if (likely(slave->error_reported)) { + printk(KERN_WARNING "EtherCAT: Reading failed on slave %04X (addr %0X)" + " - Slave type (%s %s) has no read method.\n", + slave->station_address, (unsigned int) slave, + slave->desc->vendor_name, slave->desc->product_name); + slave->error_reported = 1; + } return 0; } - if (channel >= slave->desc->channels) - { - printk(KERN_WARNING "EtherCAT: Reading failed on slave %4X (addr %0X)" - " - Type (%s %s) has no channel %i.\n", - slave->station_address, (unsigned int) slave, - slave->desc->vendor_name, slave->desc->product_name, - channel); + if (unlikely(channel >= slave->desc->channels)) { + if (likely(slave->error_reported)) { + printk(KERN_WARNING "EtherCAT: Reading failed on slave %4X (addr %0X)" + " - Type (%s %s) has no channel %i.\n", + slave->station_address, (unsigned int) slave, + slave->desc->vendor_name, slave->desc->product_name, + channel); + slave->error_reported = 1; + } return 0; } + if (unlikely(slave->error_reported)) + slave->error_reported = 0; + return slave->desc->read(slave->process_data, channel); } -/***************************************************************/ +/*****************************************************************************/ /** Schreibt einen bestimmten Kanal des Slaves als Integer-Wert . @@ -131,37 +135,48 @@ unsigned int channel, int value) { - if (!slave->desc) - { - printk(KERN_WARNING "EtherCAT: Writing failed on slave %04X (addr %0X)" - " - Slave has no description.\n", - slave->station_address, (unsigned int) slave); + if (unlikely(!slave->desc)) { + if (likely(slave->error_reported)) { + printk(KERN_WARNING "EtherCAT: Writing failed on slave %04X (addr %0X)" + " - Slave has no description.\n", + slave->station_address, (unsigned int) slave); + slave->error_reported = 1; + } return; } - if (!slave->desc->write) - { - printk(KERN_WARNING "EtherCAT: Writing failed on slave %04X (addr %0X)" - " - Type (%s %s) has no write method.\n", - slave->station_address, (unsigned int) slave, - slave->desc->vendor_name, slave->desc->product_name); + if (unlikely(!slave->desc->write)) { + if (likely(slave->error_reported)) { + printk(KERN_WARNING "EtherCAT: Writing failed on slave %04X (addr %0X)" + " - Type (%s %s) has no write method.\n", + slave->station_address, (unsigned int) slave, + slave->desc->vendor_name, slave->desc->product_name); + slave->error_reported = 1; + } return; } - if (channel >= slave->desc->channels) - { - printk(KERN_WARNING "EtherCAT: Writing failed on slave %4X (addr %0X)" - " - Type (%s %s) has no channel %i.\n", - slave->station_address, (unsigned int) slave, - slave->desc->vendor_name, slave->desc->product_name, - channel); + if (unlikely(channel >= slave->desc->channels)) { + if (likely(slave->error_reported)) { + printk(KERN_WARNING "EtherCAT: Writing failed on slave %4X (addr %0X)" + " - Type (%s %s) has no channel %i.\n", + slave->station_address, (unsigned int) slave, + slave->desc->vendor_name, slave->desc->product_name, + channel); + slave->error_reported = 1; + } return; } + if (unlikely(slave->error_reported)) + slave->error_reported = 0; + slave->desc->write(slave->process_data, channel, value); } -/***************************************************************/ +/*****************************************************************************/ EXPORT_SYMBOL(EtherCAT_write_value); EXPORT_SYMBOL(EtherCAT_read_value); + +/*****************************************************************************/ diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_slave.h --- a/drivers/ec_slave.h Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_slave.h Mon Dec 19 08:13:11 2005 +0000 @@ -1,20 +1,19 @@ -/**************************************************************** +/****************************************************************************** * * e c _ s l a v e . h * * Struktur für einen EtherCAT-Slave. * - * $Date$ - * $Author$ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #ifndef _EC_SLAVE_H_ #define _EC_SLAVE_H_ #include "ec_types.h" -/***************************************************************/ +/*****************************************************************************/ /** EtherCAT-Slave @@ -50,6 +49,7 @@ unsigned char *process_data; /**< Zeiger auf den Speicherbereich im Prozessdatenspeicher des Masters */ + int error_reported; /**< Ein Zugriffsfehler wurde bereits gemeldet. */ } EtherCAT_slave_t; @@ -57,7 +57,7 @@ TYPE, 0, ECAT_STATE_UNKNOWN, \ ECAT_STATE_UNKNOWN, NULL} -/***************************************************************/ +/*****************************************************************************/ // Slave construction and deletion void EtherCAT_slave_init(EtherCAT_slave_t *); @@ -66,6 +66,6 @@ int EtherCAT_read_value(EtherCAT_slave_t *, unsigned int); void EtherCAT_write_value(EtherCAT_slave_t *, unsigned int, int); -/***************************************************************/ +/*****************************************************************************/ #endif diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_types.c --- a/drivers/ec_types.c Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_types.c Mon Dec 19 08:13:11 2005 +0000 @@ -1,20 +1,21 @@ -/**************************************************************** +/****************************************************************************** * * e c _ t y p e s . c * * EtherCAT-Slave-Typen. * - * $Date: 2005-09-07 17:50:50 +0200 (Mit, 07 Sep 2005) $ - * $Author: fp $ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #include #include "ec_globals.h" #include "ec_types.h" -/***************************************************************/ +/*****************************************************************************/ + +/* Konfigurationen der Sync-Manager */ unsigned char sm0_multi[] = {0x00, 0x18, 0xF6, 0x00, 0x26, 0x00, 0x01, 0x00}; unsigned char sm1_multi[] = {0xF6, 0x18, 0xF6, 0x00, 0x22, 0x00, 0x01, 0x00}; @@ -28,6 +29,7 @@ unsigned char sm2_41xx[] = {0x00, 0x10, 0x04, 0x00, 0x24, 0x00, 0x01, 0x00}; +/* Konfigurationen der Memory-Management-Units */ unsigned char fmmu0_1014[] = {0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x07, 0x00, 0x10, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00}; @@ -41,6 +43,10 @@ unsigned char fmmu0_41xx[] = {0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x07, 0x00, 0x10, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00}; +/*****************************************************************************/ + +/* Lese- und Schreibfunktionen */ + int read_1014(unsigned char *data, unsigned int channel) { return (data[0] >> channel) & 0x01; @@ -69,7 +75,9 @@ data[channel * 3 + 2] = value & 0xFF; } -/***************************************************************/ +/*****************************************************************************/ + +/* Klemmen-Objekte */ EtherCAT_slave_desc_t Beckhoff_EK1100[] = {{ @@ -151,11 +159,17 @@ NULL, NULL }}; -/***************************************************************/ +/*****************************************************************************/ -unsigned int slave_idents_count = 7; +/** + Beziehung zwischen Identifikationsnummern und Klemmen-Objekt. -struct slave_ident slave_idents[] = + Diese Tabelle stellt die Beziehungen zwischen bestimmten Kombinationen + aus Vendor-IDs und Product-Codes und der entsprechenden Klemme her. + Neue Klemmen müssen hier eingetragen werden. +*/ + +EtherCAT_slave_ident_t slave_idents[] = { {0x00000002, 0x03F63052, Beckhoff_EL1014}, {0x00000002, 0x044C2C52, Beckhoff_EK1100}, @@ -167,7 +181,11 @@ {0x00000002, 0x13893052, Beckhoff_EL5001} }; -/***************************************************************/ +unsigned int slave_ident_count = sizeof(slave_idents) + / sizeof(EtherCAT_slave_ident_t); + + +/*****************************************************************************/ EXPORT_SYMBOL(Beckhoff_EK1100); EXPORT_SYMBOL(Beckhoff_EL1014); @@ -177,3 +195,5 @@ EXPORT_SYMBOL(Beckhoff_EL4102); EXPORT_SYMBOL(Beckhoff_EL4132); EXPORT_SYMBOL(Beckhoff_EL5001); + +/*****************************************************************************/ diff -r 3213cbbd58b7 -r 6965c23a6826 drivers/ec_types.h --- a/drivers/ec_types.h Fri Dec 16 16:21:22 2005 +0000 +++ b/drivers/ec_types.h Mon Dec 19 08:13:11 2005 +0000 @@ -1,13 +1,12 @@ -/**************************************************************** +/****************************************************************************** * * e c _ t y p e s . h * * EtherCAT-Slave-Typen. * - * $Date: 2005-09-07 17:50:50 +0200 (Mit, 07 Sep 2005) $ - * $Author: fp $ + * $Id$ * - ***************************************************************/ + *****************************************************************************/ #ifndef _EC_TYPES_H_ #define _EC_TYPES_H_ @@ -26,7 +25,7 @@ } EtherCAT_slave_type_t; -/***************************************************************/ +/*****************************************************************************/ /** Beschreibung eines EtherCAT-Slave-Typs. @@ -67,7 +66,7 @@ } EtherCAT_slave_desc_t; -/***************************************************************/ +/*****************************************************************************/ /** Identifikation eines Slave-Typs. @@ -76,20 +75,21 @@ Produktcodes zu den einzelnen Slave-Typen verwendet. */ -struct slave_ident +typedef struct slave_ident { const unsigned int vendor_id; /**< Hersteller-Code */ const unsigned int product_code; /**< Herstellerspezifischer Produktcode */ const EtherCAT_slave_desc_t *desc; /**< Zeiger auf den dazugehörigen Slave-Typ */ -}; +} +EtherCAT_slave_ident_t; -extern struct slave_ident slave_idents[]; /**< Statisches Array der - Slave-Identifikationen */ -extern unsigned int slave_idents_count; /**< Anzahl der bekannten Slave- - Identifikationen */ +extern EtherCAT_slave_ident_t slave_idents[]; /**< Statisches Array der + Slave-Identifikationen */ +extern unsigned int slave_ident_count; /**< Anzahl der vorhandenen + Slave-Identifikationen */ -/***************************************************************/ +/*****************************************************************************/ extern EtherCAT_slave_desc_t Beckhoff_EK1100[]; extern EtherCAT_slave_desc_t Beckhoff_EL1014[]; @@ -100,6 +100,6 @@ extern EtherCAT_slave_desc_t Beckhoff_EL4132[]; extern EtherCAT_slave_desc_t Beckhoff_EL5001[]; -/***************************************************************/ +/*****************************************************************************/ #endif