likely/unlikely, Fehlermeldungen in zyklischem Code begrenzt und Kommentare ge??ndert.
--- 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
--- 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 <linux/slab.h>
#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;
}
-/***************************************************************/
+/*****************************************************************************/
--- 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
--- 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 <linux/module.h>
#include <linux/skbuff.h>
@@ -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);
-/***************************************************************/
+/*****************************************************************************/
--- 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
--- 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
--- 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 <linux/module.h>
#include <linux/kernel.h>
@@ -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);
-/***************************************************************/
+/*****************************************************************************/
--- 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
--- 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 <linux/module.h>
#include <linux/kernel.h>
@@ -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 <hm@igh-essen.com>, Florian Pose <fp@igh-essen.com>");
+/*****************************************************************************/
+
+MODULE_AUTHOR ("Wilhelm Hagemeister <hm@igh-essen.com>,"
+ "Florian Pose <fp@igh-essen.com>");
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);
}
-/******************************************************************************/
+/*****************************************************************************/
--- 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 <linux/module.h>
#include <linux/kernel.h>
@@ -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 *);
-/******************************************************************************/
+/*****************************************************************************/
--- 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 <linux/module.h>
#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);
+
+/*****************************************************************************/
--- 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
--- 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 <linux/module.h>
#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);
+
+/*****************************************************************************/
--- 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