etherlabmaster: comparison master/device.c

equal deleted inserted replaced

-:677967864795
+:3d74183d6c6b
 #include <linux/if_ether.h>
 #include <linux/netdevice.h>
 #include <linux/delay.h>
 #include "device.h"
+#include "master.h"
 /*****************************************************************************/
 /**
 EtherCAT-Geräte-Konstuktor.
+*/
-Initialisiert ein EtherCAT-Gerät, indem es die Variablen
-in der Struktur auf die Default-Werte setzt.
+int ec_device_init(ec_device_t *device, /**< EtherCAT-Gerät */
+ec_master_t *master /**< Zugehöriger Master */
-@param ecd Zu initialisierendes EtherCAT-Gerät
+)
-*/
+{
+device->master = master;
-int ec_device_init(ec_device_t *ecd)
+device->dev = NULL;
-{
+device->open = 0;
-ecd->dev = NULL;
+device->tx_time = 0;
-ecd->open = 0;
+device->rx_time = 0;
-ecd->tx_time = 0;
+device->state = EC_DEVICE_STATE_READY;
-ecd->rx_time = 0;
+device->rx_data_size = 0;
-ecd->state = EC_DEVICE_STATE_READY;
+device->isr = NULL;
-ecd->rx_data_length = 0;
+device->module = NULL;
-ecd->isr = NULL;
+device->error_reported = 0;
-ecd->module = NULL;
-ecd->error_reported = 0;
+if ((device->tx_skb = dev_alloc_skb(ETH_HLEN + EC_MAX_FRAME_SIZE)) == NULL) {
-if ((ecd->tx_skb = dev_alloc_skb(ETH_HLEN + EC_MAX_FRAME_SIZE)) == NULL) {
 printk(KERN_ERR "EtherCAT: Error allocating device socket buffer!\n");
 return -1;
 }
 return 0;
 /**
 EtherCAT-Geräte-Destuktor.
 Gibt den dynamisch allozierten Speicher des
 EtherCAT-Gerätes (die beiden Socket-Buffer) wieder frei.
+*/
-@param ecd EtherCAT-Gerät
-*/
+void ec_device_clear(ec_device_t *device /**< EtherCAT-Gerät */)
+{
-void ec_device_clear(ec_device_t *ecd)
+if (device->open) ec_device_close(device);
-{
-if (ecd->open) ec_device_close(ecd);
+device->dev = NULL;
-ecd->dev = NULL;
+if (device->tx_skb) {
+dev_kfree_skb(device->tx_skb);
-if (ecd->tx_skb) {
+device->tx_skb = NULL;
-dev_kfree_skb(ecd->tx_skb);
-ecd->tx_skb = NULL;
 }
 }
 /*****************************************************************************/
 Dies entspricht einem "ifconfig up". Vorher wird der Zeiger
 auf das EtherCAT-Gerät auf Gültigkeit geprüft und der
 Gerätezustand zurückgesetzt.
-@param ecd EtherCAT-Gerät
+\return 0 bei Erfolg, < 0: Ungültiger Zeiger, oder open()
+fehlgeschlagen
-@return 0 bei Erfolg, < 0: Ungültiger Zeiger, oder open()
+*/
-fehlgeschlagen
-*/
+int ec_device_open(ec_device_t *device /**< EtherCAT-Gerät */)
-int ec_device_open(ec_device_t *ecd)
 {
 unsigned int i;
-if (!ecd) {
+if (!device) {
 printk(KERN_ERR "EtherCAT: Trying to open a NULL device!\n");
 return -1;
 }
-if (!ecd->dev) {
+if (!device->dev) {
 printk(KERN_ERR "EtherCAT: No net_device to open!\n");
 return -1;
 }
-if (ecd->open) {
+if (device->open) {
 printk(KERN_WARNING "EtherCAT: Device already opened!\n");
 }
 else {
 // Device could have received frames before
-for (i = 0; i < 4; i++) ec_device_call_isr(ecd);
+for (i = 0; i < 4; i++) ec_device_call_isr(device);
 // Reset old device state
-ecd->state = EC_DEVICE_STATE_READY;
+device->state = EC_DEVICE_STATE_READY;
-if (ecd->dev->open(ecd->dev) == 0) ecd->open = 1;
+if (device->dev->open(device->dev) == 0) device->open = 1;
 }
-return ecd->open ? 0 : -1;
+return device->open ? 0 : -1;
 }
 /*****************************************************************************/
 /**
 Führt die stop()-Funktion des net_devices aus.
-@param ecd EtherCAT-Gerät
+\return 0 bei Erfolg, < 0: Kein Gerät zum Schliessen oder
-@return 0 bei Erfolg, < 0: Kein Gerät zum Schliessen oder
 Schliessen fehlgeschlagen.
 */
-int ec_device_close(ec_device_t *ecd)
+int ec_device_close(ec_device_t *device /**< EtherCAT-Gerät */)
 {
-if (!ecd->dev) {
+if (!device->dev) {
 printk(KERN_ERR "EtherCAT: No device to close!\n");
 return -1;
 }
-if (!ecd->open) {
+if (!device->open) {
 printk(KERN_WARNING "EtherCAT: Device already closed!\n");
 }
 else {
-if (ecd->dev->stop(ecd->dev) == 0) ecd->open = 0;
+if (device->dev->stop(device->dev) == 0) device->open = 0;
 }
-return !ecd->open ? 0 : -1;
+return !device->open ? 0 : -1;
 }
 /*****************************************************************************/
 /**
 Bereitet den geräteinternen Socket-Buffer auf den Versand vor.
 \return Zeiger auf den Speicher, in den die Frame-Daten sollen.
 */
-uint8_t *ec_device_prepare(ec_device_t *ecd /**< EtherCAT-Gerät */)
+uint8_t *ec_device_prepare(ec_device_t *device /**< EtherCAT-Gerät */)
 {
 // Clear transmit socket buffer and reserve space for Ethernet-II header
-skb_trim(ecd->tx_skb, 0);
+skb_trim(device->tx_skb, 0);
-skb_reserve(ecd->tx_skb, ETH_HLEN);
+skb_reserve(device->tx_skb, ETH_HLEN);
 // Erstmal Speicher für maximal langen Frame reservieren
-return skb_put(ecd->tx_skb, EC_MAX_FRAME_SIZE);
+return skb_put(device->tx_skb, EC_MAX_FRAME_SIZE);
 }
 /*****************************************************************************/
 /**
 \return 0 bei Erfolg, < 0: Vorheriger Rahmen noch
 nicht empfangen, oder kein Speicher mehr vorhanden
 */
-void ec_device_send(ec_device_t *ecd, /**< EtherCAT-Gerät */
+void ec_device_send(ec_device_t *device, /**< EtherCAT-Gerät */
 unsigned int length /**< Länge der zu sendenden Daten */
 )
 {
 struct ethhdr *eth;
 // Framegroesse auf (jetzt bekannte) Laenge abschneiden
-skb_trim(ecd->tx_skb, length);
+skb_trim(device->tx_skb, length);
 // Ethernet-II-Header hinzufuegen
-eth = (struct ethhdr *) skb_push(ecd->tx_skb, ETH_HLEN);
+eth = (struct ethhdr *) skb_push(device->tx_skb, ETH_HLEN);
 eth->h_proto = htons(0x88A4);
-memcpy(eth->h_source, ecd->dev->dev_addr, ecd->dev->addr_len);
+memcpy(eth->h_source, device->dev->dev_addr, device->dev->addr_len);
-memset(eth->h_dest, 0xFF, ecd->dev->addr_len);
+memset(eth->h_dest, 0xFF, device->dev->addr_len);
-ecd->state = EC_DEVICE_STATE_SENT;
+device->state = EC_DEVICE_STATE_SENT;
-ecd->rx_data_length = 0;
+device->rx_data_size = 0;
+if (unlikely(device->master->debug_level > 1)) {
+printk(KERN_DEBUG "EtherCAT: Sending frame:\n");
+ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len);
+}
 // Senden einleiten
-rdtscl(ecd->tx_time); // Get CPU cycles
+rdtscl(device->tx_time); // Get CPU cycles
-ecd->dev->hard_start_xmit(ecd->tx_skb, ecd->dev);
+device->dev->hard_start_xmit(device->tx_skb, device->dev);
 }
 /*****************************************************************************/
 /**
 Gibt die Anzahl der empfangenen Bytes zurück.
 \return Empfangene Bytes, oder 0, wenn kein Frame empfangen wurde.
 */
-unsigned int ec_device_received(const ec_device_t *ecd)
+unsigned int ec_device_received(const ec_device_t *device)
 {
-return ecd->rx_data_length;
+return device->rx_data_size;
 }
 /*****************************************************************************/
 /**
 Gibt die empfangenen Daten zurück.
 \return Adresse auf empfangene Daten.
 */
-uint8_t *ec_device_data(ec_device_t *ecd)
+uint8_t *ec_device_data(ec_device_t *device)
 {
-return ecd->rx_data;
+return device->rx_data;
 }
 /*****************************************************************************/
 /**
 Ruft die Interrupt-Routine der Netzwerkkarte auf.
+*/
-@param ecd EtherCAT-Gerät
+void ec_device_call_isr(ec_device_t *device /**< EtherCAT-Gerät */)
-@return Anzahl der kopierten Bytes bei Erfolg, sonst < 0
+{
-*/
+if (likely(device->isr)) device->isr(0, device->dev, NULL);
-void ec_device_call_isr(ec_device_t *ecd)
-{
-if (likely(ecd->isr)) ecd->isr(0, ecd->dev, NULL);
 }
 /*****************************************************************************/
 /**
 Gibt alle Informationen über das Device-Objekt aus.
+*/
-@param ecd EtherCAT-Gerät
-*/
+void ec_device_print(ec_device_t *device /**< EtherCAT-Gerät */)
-void ec_device_print(ec_device_t *ecd)
 {
 printk(KERN_DEBUG "---EtherCAT device information begin---\n");
-if (ecd)
+if (device)
 {
 printk(KERN_DEBUG "Assigned net_device: %X\n",
-(unsigned) ecd->dev);
+(unsigned) device->dev);
 printk(KERN_DEBUG "Transmit socket buffer: %X\n",
-(unsigned) ecd->tx_skb);
+(unsigned) device->tx_skb);
 printk(KERN_DEBUG "Time of last transmission: %u\n",
-(unsigned) ecd->tx_time);
+(unsigned) device->tx_time);
 printk(KERN_DEBUG "Time of last receive: %u\n",
-(unsigned) ecd->rx_time);
+(unsigned) device->rx_time);
 printk(KERN_DEBUG "Actual device state: %i\n",
-(int) ecd->state);
+(int) device->state);
 printk(KERN_DEBUG "Receive buffer: %X\n",
-(unsigned) ecd->rx_data);
+(unsigned) device->rx_data);
 printk(KERN_DEBUG "Receive buffer fill state: %u/%u\n",
-(unsigned) ecd->rx_data_length, EC_MAX_FRAME_SIZE);
+(unsigned) device->rx_data_size, EC_MAX_FRAME_SIZE);
 }
 else
 {
 printk(KERN_DEBUG "Device is NULL!\n");
 }
 printk(KERN_DEBUG "---EtherCAT device information end---\n");
 }
+/*****************************************************************************/
+/**
+Gibt das letzte Rahmenpaar aus.
+*/
+void ec_device_debug(const ec_device_t *device /**< EtherCAT-Gerät */)
+{
+printk(KERN_DEBUG "EtherCAT: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
+ec_data_print(device->tx_skb->data + ETH_HLEN, device->tx_skb->len);
+printk(KERN_DEBUG "------------------------------------------------\n");
+ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data,
+device->rx_data_size);
+printk(KERN_DEBUG "EtherCAT: <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
+}
+/*****************************************************************************/
+/**
+Gibt Frame-Inhalte zwecks Debugging aus.
+*/
+void ec_data_print(const uint8_t *data /**< Daten */,
+size_t size /**< Anzahl Bytes */
+)
+{
+size_t i;
+printk(KERN_DEBUG);
+for (i = 0; i < size; i++) {
+printk("%02X ", data[i]);
+if ((i + 1) % 16 == 0) printk("\n" KERN_DEBUG);
+}
+printk("\n");
+}
+/*****************************************************************************/
+/**
+Gibt Frame-Inhalte zwecks Debugging aus, differentiell.
+*/
+void ec_data_print_diff(const uint8_t *d1, /**< Daten 1 */
+const uint8_t *d2, /**< Daten 2 */
+size_t size /** Anzahl Bytes */
+)
+{
+size_t i;
+printk(KERN_DEBUG);
+for (i = 0; i < size; i++) {
+if (d1[i] == d2[i]) printk(".. ");
+else printk("%02X ", d2[i]);
+if ((i + 1) % 16 == 0) printk("\n" KERN_DEBUG);
+}
+printk("\n");
+}
 /******************************************************************************
 *
 * Treiberschnittstelle
 *
 *****************************************************************************/
-void EtherCAT_dev_state(ec_device_t *ecd, ec_device_state_t state)
+/**
-{
+Setzt den Zustand des EtherCAT-Gerätes.
-ecd->state = state;
+*/
-}
+void EtherCAT_dev_state(ec_device_t *device,  /**< EtherCAT-Gerät */
-/*****************************************************************************/
+ec_device_state_t state /**< Neuer Zustand */
+)
-int EtherCAT_dev_is_ec(ec_device_t *ecd, struct net_device *dev)
+{
-{
+device->state = state;
-return ecd && ecd->dev == dev;
+}
-}
+/*****************************************************************************/
-/*****************************************************************************/
+/**
-void EtherCAT_dev_receive(ec_device_t *ecd, void *data, unsigned int size)
+Prüft, ob das Net-Device \a dev zum registrierten EtherCAT-Gerät gehört.
+*/
+int EtherCAT_dev_is_ec(const ec_device_t *device,  /**< EtherCAT-Gerät */
+const struct net_device *dev /**< Net-Device */
+)
+{
+return device && device->dev == dev;
+}
+/*****************************************************************************/
+void EtherCAT_dev_receive(ec_device_t *device, const void *data, size_t size)
 {
 // Copy received data to ethercat-device buffer
-memcpy(ecd->rx_data, data, size);
+memcpy(device->rx_data, data, size);
-ecd->rx_data_length = size;
+device->rx_data_size = size;
-ecd->state = EC_DEVICE_STATE_RECEIVED;
+device->state = EC_DEVICE_STATE_RECEIVED;
+if (unlikely(device->master->debug_level > 1)) {
+printk(KERN_DEBUG "EtherCAT: Received frame:\n");
+ec_data_print_diff(device->tx_skb->data + ETH_HLEN, device->rx_data,
+device->rx_data_size);
+}
 }
 /*****************************************************************************/
 EXPORT_SYMBOL(EtherCAT_dev_is_ec);

changeset 78	3d74183d6c6b
parent 73	9f4ea66d89a3
child 84	b4ae98855cea