# HG changeset patch # User Florian Pose # Date 1132307510 0 # Node ID 1b5aea4d5147dfe2eb149f0230a758708638a0d0 # Parent f04e93b8af0f49ad6663ee5988222552cdbfc5a5 Code zum Senden/Empfangen mehrerer Kommandos in einem Frame vorerst ganz entfernt. diff -r f04e93b8af0f -r 1b5aea4d5147 drivers/ec_command.c --- a/drivers/ec_command.c Fri Nov 18 09:35:04 2005 +0000 +++ b/drivers/ec_command.c Fri Nov 18 09:51:50 2005 +0000 @@ -30,7 +30,6 @@ cmd->type = ECAT_CMD_NONE; cmd->address.logical = 0x00000000; cmd->data_length = 0; - //cmd->next = NULL; cmd->state = ECAT_CS_READY; cmd->index = 0; cmd->working_counter = 0; diff -r f04e93b8af0f -r 1b5aea4d5147 drivers/ec_command.h --- a/drivers/ec_command.h Fri Nov 18 09:35:04 2005 +0000 +++ b/drivers/ec_command.h Fri Nov 18 09:51:50 2005 +0000 @@ -69,11 +69,6 @@ EtherCAT_address_t address; /**< Adresse des/der Empfänger */ unsigned int data_length; /**< Länge der zu sendenden und/oder empfangenen Daten */ -#if 0 - struct EtherCAT_command *next; /**< (Für den Master) Zeiger auf nächstes Kommando - in der Liste */ -#endif - 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. */ diff -r f04e93b8af0f -r 1b5aea4d5147 drivers/ec_device.c --- a/drivers/ec_device.c Fri Nov 18 09:35:04 2005 +0000 +++ b/drivers/ec_device.c Fri Nov 18 09:51:50 2005 +0000 @@ -17,6 +17,8 @@ #include "ec_device.h" #include "ec_dbg.h" +extern void rtl8139_interrupt(int, void *, struct pt_regs *); + /***************************************************************/ /** diff -r f04e93b8af0f -r 1b5aea4d5147 drivers/ec_master.c --- a/drivers/ec_master.c Fri Nov 18 09:35:04 2005 +0000 +++ b/drivers/ec_master.c Fri Nov 18 09:51:50 2005 +0000 @@ -34,8 +34,6 @@ int EtherCAT_master_init(EtherCAT_master_t *master, EtherCAT_device_t *dev) { - unsigned int i; - if (!dev) { EC_DBG(KERN_ERR "EtherCAT: Master init without device!\n"); @@ -44,24 +42,13 @@ master->slaves = NULL; master->slave_count = 0; - //master->first_command = NULL; - //master->process_data_command = NULL; master->dev = dev; master->command_index = 0x00; master->tx_data_length = 0; master->process_data = NULL; master->process_data_length = 0; - //master->cmd_ring_index = 0; master->debug_level = 0; -#if 0 - for (i = 0; i < ECAT_COMMAND_RING_SIZE; i++) - { - EtherCAT_command_init(&master->cmd_ring[i]); - master->cmd_reserved[i] = 0; - } -#endif - return 0; } @@ -78,14 +65,6 @@ void EtherCAT_master_clear(EtherCAT_master_t *master) { -#if 0 - // Remove all pending commands - while (master->first_command) - { - EtherCAT_remove_command(master, master->first_command); - } -#endif - // Remove all slaves EtherCAT_clear_slaves(master); @@ -101,648 +80,6 @@ /***************************************************************/ /** - Überprüft die angeschlossenen Slaves. - - Vergleicht die an den Bus angeschlossenen Slaves mit - den im statischen-Slave-Array vorgegebenen Konfigurationen. - Stimmen Anzahl oder Typen nicht überein, gibt diese - Methode einen Fehler aus. - - @param master Der EtherCAT-Master - @param slaves Zeiger auf ein statisches Slave-Array - @param slave_count Anzahl der Slaves im Array - - @return 0 bei Erfolg, sonst < 0 -*/ - -int EtherCAT_check_slaves(EtherCAT_master_t *master, - EtherCAT_slave_t *slaves, - unsigned int slave_count) -{ - EtherCAT_command_t cmd; - EtherCAT_slave_t *cur; - unsigned int i, j, found, length, pos; - unsigned char data[2]; - - // EtherCAT_clear_slaves() must be called before! - if (master->slaves || master->slave_count) - { - EC_DBG(KERN_ERR "EtherCAT duplicate slave check!"); - return -1; - } - - // No slaves. - if (slave_count == 0) - { - EC_DBG(KERN_ERR "EtherCAT: No slaves in list!"); - return -1; - } - - // Determine number of slaves on bus - - EtherCAT_command_broadcast_read(&cmd, 0x0000, 4); - - if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; - - if (cmd.working_counter != slave_count) - { - EC_DBG(KERN_ERR "EtherCAT: Wrong number of slaves on bus: %i / %i\n", - cmd.working_counter, slave_count); - return -1; - } - else - { - EC_DBG("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) - { - EC_DBG(KERN_ERR "EtherCAT: Slave %i has no description.\n", i); - return -1; - } - - // Set ring position - cur->ring_position = -i; - cur->station_address = i + 1; - - // Write station address - - 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) - { - EC_DBG(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) - { - EC_DBG(KERN_ERR "EtherCAT: Slave %i did not respond while reading base data!\n", i); - return -1; - } - - // Get base data - cur->type = cmd.data[0]; - cur->revision = cmd.data[1]; - cur->build = cmd.data[2] | (cmd.data[3] << 8); - - // Read identification from "Slave Information Interface" (SII) - - if (EtherCAT_read_slave_information(master, cur->station_address, - 0x0008, &cur->vendor_id) != 0) - { - EC_DBG(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) - { - EC_DBG(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) - { - EC_DBG(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) - { - EC_DBG(KERN_ERR "EtherCAT: Could not read SII serial number!\n"); - return -1; - } - - // Search for identification in "database" - - found = 0; - - for (j = 0; j < slave_idents_count; j++) - { - if (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) - { - EC_DBG(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); - return -1; - } - - break; - } - } - - if (!found) - { - EC_DBG(KERN_ERR "EtherCAT: Unknown slave device" - " (vendor %X, code %X) at position %i.\n", - i, cur->vendor_id, cur->product_code); - return -1; - } - } - - length = 0; - for (i = 0; i < slave_count; i++) - { - length += slaves[i].desc->data_length; - } - - if ((master->process_data = (unsigned char *) - kmalloc(sizeof(unsigned char) * length, GFP_KERNEL)) == NULL) - { - EC_DBG(KERN_ERR "EtherCAT: Could not allocate %i bytes for process data.\n", length); - return -1; - } - - master->process_data_length = length; - memset(master->process_data, 0x00, length); - - pos = 0; - for (i = 0; i < slave_count; i++) - { - slaves[i].process_data = master->process_data + pos; - slaves[i].logical_address0 = pos; - - EC_DBG(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; - } - - master->slaves = slaves; - master->slave_count = slave_count; - - return 0; -} - -/***************************************************************/ - -/** - Entfernt den Zeiger auf das Slave-Array. - - @param master EtherCAT-Master -*/ - -void EtherCAT_clear_slaves(EtherCAT_master_t *master) -{ - master->slaves = NULL; - master->slave_count = 0; -} - -/***************************************************************/ - -/** - Liest Daten aus dem Slave-Information-Interface - eines EtherCAT-Slaves. - - @param master EtherCAT-Master - @param node_address Knotenadresse des Slaves - @param offset Adresse des zu lesenden SII-Registers - @param target Zeiger auf einen 4 Byte großen Speicher - zum Ablegen der Daten - - @return 0 bei Erfolg, sonst < 0 -*/ - -int EtherCAT_read_slave_information(EtherCAT_master_t *master, - unsigned short int node_address, - unsigned short int offset, - unsigned int *target) -{ - EtherCAT_command_t cmd; - unsigned char data[10]; - unsigned int tries_left; - - // Initiate read operation - - data[0] = 0x00; - data[1] = 0x01; - data[2] = offset & 0xFF; - data[3] = (offset & 0xFF00) >> 8; - data[4] = 0x00; - 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) - { - EC_DBG(KERN_ERR "EtherCAT: SII-read - Slave %04X did not respond!\n", - node_address); - return -4; - } - - // Der Slave legt die Informationen des Slave-Information-Interface - // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange - // den Status auslesen, bis das Bit weg ist. - - tries_left = 100; - while (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) - { - EC_DBG(KERN_ERR "EtherCAT: SII-read status - Slave %04X did not respond!\n", - node_address); - return -4; - } - - if ((cmd.data[1] & 0x81) == 0) - { - memcpy(target, cmd.data + 6, 4); - break; - } - - tries_left--; - } - - if (!tries_left) - { - EC_DBG(KERN_WARNING "EtherCAT: SSI-read. Slave %04X timed out!\n", - node_address); - return -1; - } - - return 0; -} - -#if 0 -/***************************************************************/ - -/** - Führt ein asynchrones Senden und Empfangen aus. - - Sendet alle wartenden Kommandos und wartet auf die - entsprechenden Antworten. - - @param master EtherCAT-Master - - @return 0 bei Erfolg, sonst < 0 -*/ - -int EtherCAT_async_send_receive(EtherCAT_master_t *master) -{ - unsigned int wait_cycles; - int i; - - // Send all commands - - for (i = 0; i < ECAT_NUM_RETRIES; i++) - { - if (EtherCAT_send(master) < 0) - { - return -1; - } - - // Wait until something is received or an error has occurred - - wait_cycles = 10; - EtherCAT_device_call_isr(master->dev); - - while (master->dev->state == ECAT_DS_SENT && wait_cycles) - { - udelay(1000); - wait_cycles--; - EtherCAT_device_call_isr(master->dev); - } - - //EC_DBG("Master async send: tries %d",tries_left); - - if (!wait_cycles) - { - EC_DBG(KERN_ERR "EtherCAT: Asynchronous receive timeout.\n"); - continue; - } - - if (master->dev->state != ECAT_DS_RECEIVED) - { - EC_DBG(KERN_ERR "EtherCAT: Asyncronous send error. State %i\n", master->dev->state); - continue; - } - - // Receive all commands - if (EtherCAT_receive(master) < 0) - { - // Noch mal versuchen - master->dev->state = ECAT_DS_READY; - EC_DBG("Retry Asynchronous send/recieve: %d", i); - continue; - } - - return 0; // Erfolgreich - } - - return -1; -} - -/***************************************************************/ - -/** - Sendet alle wartenden Kommandos. - - Errechnet erst die benötigte Gesamt-Rahmenlänge, und erstellt - dann alle Kommando-Bytefolgen im statischen Sendespeicher. - Danach wird die Sendefunktion des EtherCAT-Gerätes aufgerufen. - - @param master EtherCAT-Master - - @return 0 bei Erfolg, sonst < 0 -*/ - -int EtherCAT_send(EtherCAT_master_t *master) -{ - unsigned int i, length, framelength, pos; - EtherCAT_command_t *cmd; - int cmdcnt = 0; - - if (master->debug_level > 0) - { - EC_DBG(KERN_DEBUG "EtherCAT_send, first_command = %X\n", (int) master->first_command); - } - - length = 0; - for (cmd = master->first_command; cmd != NULL; cmd = cmd->next) - { - if (cmd->state != ECAT_CS_READY) continue; - length += cmd->data_length + 12; - cmdcnt++; - } - - if (master->debug_level > 0) - { - EC_DBG(KERN_DEBUG "%i commands to send.\n", cmdcnt); - } - - if (length == 0) - { - EC_DBG(KERN_WARNING "EtherCAT: Nothing to send...\n"); - return 0; - } - - framelength = length + 2; - if (framelength < 46) framelength = 46; - - if (master->debug_level > 0) - { - EC_DBG(KERN_DEBUG "framelength: %i\n", framelength); - } - - master->tx_data[0] = length & 0xFF; - master->tx_data[1] = ((length & 0x700) >> 8) | 0x10; - pos = 2; - - for (cmd = master->first_command; cmd != NULL; cmd = cmd->next) - { - if (cmd->state != ECAT_CS_READY) continue; - - cmd->index = master->command_index; - master->command_index = (master->command_index + 1) % 0x0100; - - if (master->debug_level > 0) - { - EC_DBG(KERN_DEBUG "Sending command index %i\n", cmd->index); - } - - cmd->state = ECAT_CS_SENT; - - master->tx_data[pos + 0] = cmd->type; - master->tx_data[pos + 1] = cmd->index; - - master->tx_data[pos + 2] = cmd->address.raw[0]; - master->tx_data[pos + 3] = cmd->address.raw[1]; - master->tx_data[pos + 4] = cmd->address.raw[2]; - master->tx_data[pos + 5] = cmd->address.raw[3]; - - master->tx_data[pos + 6] = cmd->data_length & 0xFF; - master->tx_data[pos + 7] = (cmd->data_length & 0x700) >> 8; - - if (cmd->next) master->tx_data[pos + 7] |= 0x80; - - master->tx_data[pos + 8] = 0x00; - master->tx_data[pos + 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[pos + 10 + i] = cmd->data[i]; - } - else // Read - { - for (i = 0; i < cmd->data_length; i++) master->tx_data[pos + 10 + i] = 0x00; - } - - master->tx_data[pos + 10 + cmd->data_length] = 0x00; - master->tx_data[pos + 11 + cmd->data_length] = 0x00; - - pos += 12 + cmd->data_length; - } - - // Pad with zeros - while (pos < 46) master->tx_data[pos++] = 0x00; - - master->tx_data_length = framelength; - -#ifdef DEBUG_SEND_RECEIVE - EC_DBG(KERN_DEBUG "\n"); - EC_DBG(KERN_DEBUG ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n"); - EC_DBG(KERN_DEBUG); - for (i = 0; i < framelength; i++) - { - EC_DBG("%02X ", master->tx_data[i]); - - if ((i + 1) % 16 == 0) EC_DBG("\n" KERN_DEBUG); - } - EC_DBG("\n"); - EC_DBG(KERN_DEBUG "-----------------------------------------------\n"); -#endif - - if (master->debug_level > 0) - { - EC_DBG(KERN_DEBUG "device send...\n"); - } - - // Send frame - if (EtherCAT_device_send(master->dev, master->tx_data, framelength) != 0) - { - EC_DBG(KERN_ERR "EtherCAT: Could not send!\n"); - EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n"); - output_debug_data(master->tx_data, framelength); - return -1; - } - - if (master->debug_level > 0) - { - EC_DBG(KERN_DEBUG "EtherCAT_send done.\n"); - } - - return 0; -} - -/***************************************************************/ - -/** - Holt alle empfangenen Kommandos vom EtherCAT-Gerät. - - Kopiert einen empfangenen Rahmen vom EtherCAT-Gerät - in den Statischen Empfangsspeicher und ordnet dann - allen gesendeten Kommandos ihre Antworten zu. - - @param master EtherCAT-Master - - @return 0 bei Erfolg, sonst < 0 -*/ - -int EtherCAT_receive(EtherCAT_master_t *master) -{ - EtherCAT_command_t *cmd; - unsigned int length, pos, found, rx_data_length; - unsigned int command_follows, command_type, command_index; - - // Copy received data into master buffer (with locking) - rx_data_length = EtherCAT_device_receive(master->dev, master->rx_data, - ECAT_FRAME_BUFFER_SIZE); - -#ifdef DEBUG_SEND_RECEIVE - for (i = 0; i < rx_data_length; i++) - { - if (master->rx_data[i] == master->tx_data[i]) EC_DBG(" "); - else EC_DBG("%02X ", master->rx_data[i]); - if ((i + 1) % 16 == 0) EC_DBG("\n" KERN_DEBUG); - } - EC_DBG("\n"); - EC_DBG(KERN_DEBUG "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); - EC_DBG(KERN_DEBUG "\n"); -#endif - - if (rx_data_length < 2) - { - EC_DBG(KERN_ERR "EtherCAT: Received corrupted frame (illegal length)!\n"); - EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n"); - output_debug_data(master->tx_data, master->tx_data_length); - EC_DBG(KERN_DEBUG "EtherCAT: rx_data content:\n"); - output_debug_data(master->rx_data, rx_data_length); - return -1; - } - - // Länge des gesamten Frames prüfen - length = ((master->rx_data[1] & 0x07) << 8) | (master->rx_data[0] & 0xFF); - - if (length > rx_data_length) - { - EC_DBG(KERN_ERR "EtherCAT: Received corrupted frame (length does not match)!\n"); - EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n"); - output_debug_data(master->tx_data, master->tx_data_length); - EC_DBG(KERN_DEBUG "EtherCAT: rx_data content:\n"); - output_debug_data(master->rx_data, rx_data_length); - return -1; - } - - pos = 2; // LibPCAP: 16 - command_follows = 1; - while (command_follows) - { - if (pos + 10 > rx_data_length) - { - EC_DBG(KERN_ERR "EtherCAT: Received frame with incomplete command header!\n"); - EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n"); - output_debug_data(master->tx_data, master->tx_data_length); - EC_DBG(KERN_DEBUG "EtherCAT: rx_data content:\n"); - output_debug_data(master->rx_data, rx_data_length); - return -1; - } - - command_type = master->rx_data[pos]; - command_index = master->rx_data[pos + 1]; - length = (master->rx_data[pos + 6] & 0xFF) - | ((master->rx_data[pos + 7] & 0x07) << 8); - command_follows = master->rx_data[pos + 7] & 0x80; - - if (pos + length + 12 > rx_data_length) - { - EC_DBG(KERN_ERR "EtherCAT: Received frame with incomplete command data!\n"); - EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n"); - output_debug_data(master->tx_data, master->tx_data_length); - EC_DBG(KERN_DEBUG "EtherCAT: rx_data content:\n"); - output_debug_data(master->rx_data, rx_data_length); - return -1; - } - - found = 0; - - for (cmd = master->first_command; cmd != NULL; cmd = cmd->next) - { - if (cmd->state == ECAT_CS_SENT - && cmd->type == command_type - && cmd->index == command_index - && cmd->data_length == length) - { - found = 1; - cmd->state = ECAT_CS_RECEIVED; - - // Empfangene Daten in Kommandodatenspeicher kopieren - memcpy(cmd->data, master->rx_data + pos + 10, length); - - // Working-Counter setzen - cmd->working_counter = (master->rx_data[pos + length + 10] & 0xFF) - | ((master->rx_data[pos + length + 11] & 0xFF) << 8); - } - } - - if (!found) - { - EC_DBG(KERN_WARNING "EtherCAT: WARNING - Command not assigned!\n"); - } - - pos += length + 12; - } - - for (cmd = master->first_command; cmd != NULL; cmd = cmd->next) - { - if (cmd->state == ECAT_CS_SENT) - { - EC_DBG(KERN_WARNING "EtherCAT: WARNING - One command received no response!\n"); - } - } - - master->dev->state = ECAT_DS_READY; - - return 0; -} -#endif - -/***************************************************************/ - -/** Sendet ein einzelnes Kommando in einem Frame und wartet auf dessen Empfang. @@ -959,378 +296,299 @@ /***************************************************************/ -#if 0 - -#define ECAT_FUNC_HEADER \ - EtherCAT_command_t *cmd; \ - if ((cmd = alloc_cmd(master)) == NULL) \ - { \ - EC_DBG(KERN_ERR "EtherCAT: Out of memory while creating command!\n"); \ - return NULL; \ - } \ - EtherCAT_command_init(cmd) - -#define ECAT_FUNC_WRITE_FOOTER \ - cmd->data_length = length; \ - memcpy(cmd->data, data, length); \ - if (add_command(master, cmd) < 0) return NULL; \ - return cmd - -#define ECAT_FUNC_READ_FOOTER \ - cmd->data_length = length; \ - if (add_command(master, cmd) < 0) return NULL; \ - return cmd - -/***************************************************************/ - -/** - Erstellt ein EtherCAT-NPRD-Kommando. - - Alloziert ein "node-adressed physical read"-Kommando - und fügt es in die Liste des Masters ein. - - @param master EtherCAT-Master - @param node_address Adresse des Knotens (Slaves) - @param offset Physikalische Speicheradresse im Slave - @param length Länge der zu lesenden Daten - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *EtherCAT_read(EtherCAT_master_t *master, - unsigned short node_address, - unsigned short offset, - unsigned int length) -{ - if (node_address == 0x0000) - EC_DBG(KERN_WARNING "EtherCAT: Using node address 0x0000!\n"); - - ECAT_FUNC_HEADER; - - cmd->type = ECAT_CMD_NPRD; - cmd->address.phy.dev.node = node_address; - cmd->address.phy.mem = offset; - - ECAT_FUNC_READ_FOOTER; -} - -/***************************************************************/ - -/** - Erstellt ein EtherCAT-NPWR-Kommando. - - Alloziert ein "node-adressed physical write"-Kommando - und fügt es in die Liste des Masters ein. - - @param master EtherCAT-Master - @param node_address Adresse des Knotens (Slaves) - @param offset Physikalische Speicheradresse im Slave - @param length Länge der zu schreibenden Daten - @param data Zeiger auf Speicher mit zu schreibenden Daten - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *EtherCAT_write(EtherCAT_master_t *master, - unsigned short node_address, - unsigned short offset, - unsigned int length, - const unsigned char *data) -{ - if (node_address == 0x0000) - EC_DBG(KERN_WARNING "WARNING: Using node address 0x0000!\n"); - - ECAT_FUNC_HEADER; - - cmd->type = ECAT_CMD_NPWR; - cmd->address.phy.dev.node = node_address; - cmd->address.phy.mem = offset; - - ECAT_FUNC_WRITE_FOOTER; -} - -/***************************************************************/ - -/** - Erstellt ein EtherCAT-APRD-Kommando. - - Alloziert ein "autoincerement physical read"-Kommando - und fügt es in die Liste des Masters ein. - - @param master EtherCAT-Master - @param ring_position (Negative) Position des Slaves im Bus - @param offset Physikalische Speicheradresse im Slave - @param length Länge der zu lesenden Daten - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *EtherCAT_position_read(EtherCAT_master_t *master, - short ring_position, - unsigned short offset, - unsigned int length) -{ - ECAT_FUNC_HEADER; - - cmd->type = ECAT_CMD_APRD; - cmd->address.phy.dev.pos = ring_position; - cmd->address.phy.mem = offset; - - ECAT_FUNC_READ_FOOTER; -} - -/***************************************************************/ - -/** - Erstellt ein EtherCAT-APWR-Kommando. - - Alloziert ein "autoincrement physical write"-Kommando - und fügt es in die Liste des Masters ein. - - @param master EtherCAT-Master - @param ring_position (Negative) Position des Slaves im Bus - @param offset Physikalische Speicheradresse im Slave - @param length Länge der zu schreibenden Daten - @param data Zeiger auf Speicher mit zu schreibenden Daten - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *EtherCAT_position_write(EtherCAT_master_t *master, - short ring_position, - unsigned short offset, - unsigned int length, - const unsigned char *data) -{ - ECAT_FUNC_HEADER; - - cmd->type = ECAT_CMD_APWR; - cmd->address.phy.dev.pos = ring_position; - cmd->address.phy.mem = offset; - - ECAT_FUNC_WRITE_FOOTER; -} - -/***************************************************************/ - -/** - Erstellt ein EtherCAT-BRD-Kommando. - - Alloziert ein "broadcast read"-Kommando - und fügt es in die Liste des Masters ein. - - @param master EtherCAT-Master - @param offset Physikalische Speicheradresse im Slave - @param length Länge der zu lesenden Daten - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *EtherCAT_broadcast_read(EtherCAT_master_t *master, - unsigned short offset, - unsigned int length) -{ - ECAT_FUNC_HEADER; - - cmd->type = ECAT_CMD_BRD; - cmd->address.phy.dev.node = 0x0000; - cmd->address.phy.mem = offset; - - ECAT_FUNC_READ_FOOTER; -} - -/***************************************************************/ - -/** - Erstellt ein EtherCAT-BWR-Kommando. - - Alloziert ein "broadcast write"-Kommando - und fügt es in die Liste des Masters ein. - - @param master EtherCAT-Master - @param offset Physikalische Speicheradresse im Slave - @param length Länge der zu schreibenden Daten - @param data Zeiger auf Speicher mit zu schreibenden Daten - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *EtherCAT_broadcast_write(EtherCAT_master_t *master, - unsigned short offset, - unsigned int length, - const unsigned char *data) -{ - ECAT_FUNC_HEADER; - - cmd->type = ECAT_CMD_BWR; - cmd->address.phy.dev.node = 0x0000; - cmd->address.phy.mem = offset; - - ECAT_FUNC_WRITE_FOOTER; -} - -/***************************************************************/ - -/** - Erstellt ein EtherCAT-LRW-Kommando. - - Alloziert ein "logical read write"-Kommando - und fügt es in die Liste des Masters ein. - - @param master EtherCAT-Master - @param offset Logische Speicheradresse - @param length Länge der zu lesenden/schreibenden Daten - @param data Zeiger auf Speicher mit zu lesenden/schreibenden Daten - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *EtherCAT_logical_read_write(EtherCAT_master_t *master, - unsigned int offset, - unsigned int length, - unsigned char *data) -{ - ECAT_FUNC_HEADER; - - cmd->type = ECAT_CMD_LRW; - cmd->address.logical = offset; - - ECAT_FUNC_WRITE_FOOTER; -} - -/***************************************************************/ - -/** - Alloziert ein neues Kommando aus dem Kommandoring. - - Durchsucht den Kommandoring nach einem freien Kommando, - reserviert es und gibt dessen Adresse zurück. - - @param master EtherCAT-Master - - @return Adresse des Kommandos bei Erfolg, sonst NULL -*/ - -EtherCAT_command_t *alloc_cmd(EtherCAT_master_t *master) -{ - int j; - - for (j = 0; j < ECAT_COMMAND_RING_SIZE; j++) // Einmal rum suchen - { - // Solange suchen, bis freies Kommando gefunden - if (master->cmd_reserved[master->cmd_ring_index] == 0) - { - master->cmd_reserved[master->cmd_ring_index] = 1; // Belegen - - if (master->debug_level) +/** + Überprüft die angeschlossenen Slaves. + + Vergleicht die an den Bus angeschlossenen Slaves mit + den im statischen-Slave-Array vorgegebenen Konfigurationen. + Stimmen Anzahl oder Typen nicht überein, gibt diese + Methode einen Fehler aus. + + @param master Der EtherCAT-Master + @param slaves Zeiger auf ein statisches Slave-Array + @param slave_count Anzahl der Slaves im Array + + @return 0 bei Erfolg, sonst < 0 +*/ + +int EtherCAT_check_slaves(EtherCAT_master_t *master, + EtherCAT_slave_t *slaves, + unsigned int slave_count) +{ + EtherCAT_command_t cmd; + EtherCAT_slave_t *cur; + unsigned int i, j, found, length, pos; + unsigned char data[2]; + + // EtherCAT_clear_slaves() must be called before! + if (master->slaves || master->slave_count) + { + EC_DBG(KERN_ERR "EtherCAT duplicate slave check!"); + return -1; + } + + // No slaves. + if (slave_count == 0) + { + EC_DBG(KERN_ERR "EtherCAT: No slaves in list!"); + return -1; + } + + // Determine number of slaves on bus + + EtherCAT_command_broadcast_read(&cmd, 0x0000, 4); + + if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1; + + if (cmd.working_counter != slave_count) + { + EC_DBG(KERN_ERR "EtherCAT: Wrong number of slaves on bus: %i / %i\n", + cmd.working_counter, slave_count); + return -1; + } + else + { + EC_DBG("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) + { + EC_DBG(KERN_ERR "EtherCAT: Slave %i has no description.\n", i); + return -1; + } + + // Set ring position + cur->ring_position = -i; + cur->station_address = i + 1; + + // Write station address + + 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) + { + EC_DBG(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) + { + EC_DBG(KERN_ERR "EtherCAT: Slave %i did not respond while reading base data!\n", i); + return -1; + } + + // Get base data + cur->type = cmd.data[0]; + cur->revision = cmd.data[1]; + cur->build = cmd.data[2] | (cmd.data[3] << 8); + + // Read identification from "Slave Information Interface" (SII) + + if (EtherCAT_read_slave_information(master, cur->station_address, + 0x0008, &cur->vendor_id) != 0) + { + EC_DBG(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) + { + EC_DBG(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) + { + EC_DBG(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) + { + EC_DBG(KERN_ERR "EtherCAT: Could not read SII serial number!\n"); + return -1; + } + + // Search for identification in "database" + + found = 0; + + for (j = 0; j < slave_idents_count; j++) + { + if (slave_idents[j].vendor_id == cur->vendor_id + && slave_idents[j].product_code == cur->product_code) { - EC_DBG(KERN_DEBUG "Allocating command %i (addr %X).\n", - master->cmd_ring_index, - (int) &master->cmd_ring[master->cmd_ring_index]); + found = 1; + + if (cur->desc != slave_idents[j].desc) + { + EC_DBG(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); + return -1; + } + + break; } - - return &master->cmd_ring[master->cmd_ring_index]; - } - - if (master->debug_level) - { - EC_DBG(KERN_DEBUG "Command %i (addr %X) is reserved...\n", - master->cmd_ring_index, - (int) &master->cmd_ring[master->cmd_ring_index]); - } - - master->cmd_ring_index++; - master->cmd_ring_index %= ECAT_COMMAND_RING_SIZE; - } - - EC_DBG(KERN_WARNING "EtherCAT: Command ring full!\n"); - - return NULL; // Nix gefunden -} - -/***************************************************************/ - -/** - Fügt ein Kommando in die Liste des Masters ein. - - @param master EtherCAT-Master - @param cmd Zeiger auf das einzufügende Kommando -*/ - -int add_command(EtherCAT_master_t *master, - EtherCAT_command_t *new_cmd) -{ - EtherCAT_command_t *cmd, **last_cmd; - - for (cmd = master->first_command; cmd != NULL; cmd = cmd->next) - { - if (cmd == new_cmd) - { - EC_DBG(KERN_WARNING "EtherCAT: Trying to add a command" - " that is already in the list!\n"); + } + + if (!found) + { + EC_DBG(KERN_ERR "EtherCAT: Unknown slave device" + " (vendor %X, code %X) at position %i.\n", + i, cur->vendor_id, cur->product_code); return -1; } } - // Find the address of the last pointer in the list - last_cmd = &(master->first_command); - while (*last_cmd) last_cmd = &(*last_cmd)->next; - - // Let this pointer point to the new command - *last_cmd = new_cmd; - - return 0; -} - -/***************************************************************/ - -/** - Entfernt ein Kommando aus der Liste und gibt es frei. - - Prüft erst, ob das Kommando in der Liste des Masters - ist. Wenn ja, wird es entfernt und die Reservierung wird - aufgehoben. - - @param master EtherCAT-Master - @param rem_cmd Zeiger auf das zu entfernende Kommando - - @return 0 bei Erfolg, sonst < 0 -*/ - -void EtherCAT_remove_command(EtherCAT_master_t *master, - EtherCAT_command_t *rem_cmd) -{ - EtherCAT_command_t **last_cmd; - int i; - - last_cmd = &master->first_command; - while (*last_cmd) - { - if (*last_cmd == rem_cmd) - { - *last_cmd = rem_cmd->next; - EtherCAT_command_clear(rem_cmd); - - // Reservierung des Kommandos aufheben - for (i = 0; i < ECAT_COMMAND_RING_SIZE; i++) - { - if (&master->cmd_ring[i] == rem_cmd) - { - master->cmd_reserved[i] = 0; - return; - } - } - - EC_DBG(KERN_WARNING "EtherCAT: Could not remove command reservation!\n"); - return; - } - - last_cmd = &(*last_cmd)->next; - } - - EC_DBG(KERN_WARNING "EtherCAT: Trying to remove non-existent command!\n"); -} -#endif + length = 0; + for (i = 0; i < slave_count; i++) + { + length += slaves[i].desc->data_length; + } + + if ((master->process_data = (unsigned char *) + kmalloc(sizeof(unsigned char) * length, GFP_KERNEL)) == NULL) + { + EC_DBG(KERN_ERR "EtherCAT: Could not allocate %i bytes for process data.\n", length); + return -1; + } + + master->process_data_length = length; + memset(master->process_data, 0x00, length); + + pos = 0; + for (i = 0; i < slave_count; i++) + { + slaves[i].process_data = master->process_data + pos; + slaves[i].logical_address0 = pos; + + EC_DBG(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; + } + + master->slaves = slaves; + master->slave_count = slave_count; + + return 0; +} + +/***************************************************************/ + +/** + Entfernt den Zeiger auf das Slave-Array. + + @param master EtherCAT-Master +*/ + +void EtherCAT_clear_slaves(EtherCAT_master_t *master) +{ + master->slaves = NULL; + master->slave_count = 0; +} + +/***************************************************************/ + +/** + Liest Daten aus dem Slave-Information-Interface + eines EtherCAT-Slaves. + + @param master EtherCAT-Master + @param node_address Knotenadresse des Slaves + @param offset Adresse des zu lesenden SII-Registers + @param target Zeiger auf einen 4 Byte großen Speicher + zum Ablegen der Daten + + @return 0 bei Erfolg, sonst < 0 +*/ + +int EtherCAT_read_slave_information(EtherCAT_master_t *master, + unsigned short int node_address, + unsigned short int offset, + unsigned int *target) +{ + EtherCAT_command_t cmd; + unsigned char data[10]; + unsigned int tries_left; + + // Initiate read operation + + data[0] = 0x00; + data[1] = 0x01; + data[2] = offset & 0xFF; + data[3] = (offset & 0xFF00) >> 8; + data[4] = 0x00; + 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) + { + EC_DBG(KERN_ERR "EtherCAT: SII-read - Slave %04X did not respond!\n", + node_address); + return -4; + } + + // Der Slave legt die Informationen des Slave-Information-Interface + // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange + // den Status auslesen, bis das Bit weg ist. + + tries_left = 100; + while (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) + { + EC_DBG(KERN_ERR "EtherCAT: SII-read status - Slave %04X did not respond!\n", + node_address); + return -4; + } + + if ((cmd.data[1] & 0x81) == 0) + { + memcpy(target, cmd.data + 6, 4); + break; + } + + tries_left--; + } + + if (!tries_left) + { + EC_DBG(KERN_WARNING "EtherCAT: SSI-read. Slave %04X timed out!\n", + node_address); + return -1; + } + + return 0; +} /***************************************************************/ diff -r f04e93b8af0f -r 1b5aea4d5147 drivers/ec_master.h --- a/drivers/ec_master.h Fri Nov 18 09:35:04 2005 +0000 +++ b/drivers/ec_master.h Fri Nov 18 09:51:50 2005 +0000 @@ -31,10 +31,6 @@ mit Slave-Informationen */ unsigned int slave_count; /**< Anzahl der Slaves in slaves */ -#if 0 - EtherCAT_command_t *first_command; /**< Zeiger auf das erste - Kommando in der Liste */ -#endif EtherCAT_command_t process_data_command; /**< Kommando zum Senden und Empfangen der Prozessdaten */ @@ -52,12 +48,6 @@ unsigned char *process_data; /**< Zeiger auf Speicher mit Prozessdaten */ unsigned int process_data_length; /**< Länge der Prozessdaten */ -#if 0 - EtherCAT_command_t cmd_ring[ECAT_COMMAND_RING_SIZE]; /**< Statischer Kommandoring */ - int cmd_reserved[ECAT_COMMAND_RING_SIZE]; /**< Reservierungsflags für die Kommandos */ - unsigned int cmd_ring_index; /**< Index des nächsten Kommandos im Ring */ -#endif - int debug_level; /**< Debug-Level im Master-Code */ } EtherCAT_master_t; @@ -68,81 +58,30 @@ int EtherCAT_master_init(EtherCAT_master_t *, EtherCAT_device_t *); void EtherCAT_master_clear(EtherCAT_master_t *); +// Sending and receiving +int EtherCAT_simple_send_receive(EtherCAT_master_t *, EtherCAT_command_t *); +int EtherCAT_simple_send(EtherCAT_master_t *, EtherCAT_command_t *); +int EtherCAT_simple_receive(EtherCAT_master_t *, EtherCAT_command_t *); + // Slave management int EtherCAT_check_slaves(EtherCAT_master_t *, EtherCAT_slave_t *, unsigned int); void EtherCAT_clear_slaves(EtherCAT_master_t *); +int EtherCAT_read_slave_information(EtherCAT_master_t *, + unsigned short int, + unsigned short int, + unsigned int *); int EtherCAT_activate_slave(EtherCAT_master_t *, EtherCAT_slave_t *); int EtherCAT_deactivate_slave(EtherCAT_master_t *, EtherCAT_slave_t *); int EtherCAT_activate_all_slaves(EtherCAT_master_t *); int EtherCAT_deactivate_all_slaves(EtherCAT_master_t *); +int EtherCAT_state_change(EtherCAT_master_t *, EtherCAT_slave_t *, unsigned char); -// Sending and receiving -#if 0 -int EtherCAT_async_send_receive(EtherCAT_master_t *); -int EtherCAT_send(EtherCAT_master_t *); -int EtherCAT_receive(EtherCAT_master_t *); -#endif -int EtherCAT_simple_send_receive(EtherCAT_master_t *, EtherCAT_command_t *); -int EtherCAT_simple_send(EtherCAT_master_t *, EtherCAT_command_t *); -int EtherCAT_simple_receive(EtherCAT_master_t *, EtherCAT_command_t *); - +// Process data int EtherCAT_write_process_data(EtherCAT_master_t *); int EtherCAT_read_process_data(EtherCAT_master_t *); void EtherCAT_clear_process_data(EtherCAT_master_t *); -/***************************************************************/ - -// Slave information interface -int EtherCAT_read_slave_information(EtherCAT_master_t *, - unsigned short int, - unsigned short int, - unsigned int *); - -// EtherCAT commands -#if 0 -EtherCAT_command_t *EtherCAT_read(EtherCAT_master_t *, - unsigned short, - unsigned short, - unsigned int); -EtherCAT_command_t *EtherCAT_write(EtherCAT_master_t *, - unsigned short, - unsigned short, - unsigned int, - const unsigned char *); -EtherCAT_command_t *EtherCAT_position_read(EtherCAT_master_t *, - short, - unsigned short, - unsigned int); -EtherCAT_command_t *EtherCAT_position_write(EtherCAT_master_t *, - short, - unsigned short, - unsigned int, - const unsigned char *); -EtherCAT_command_t *EtherCAT_broadcast_read(EtherCAT_master_t *, - unsigned short, - unsigned int); -EtherCAT_command_t *EtherCAT_broadcast_write(EtherCAT_master_t *, - unsigned short, - unsigned int, - const unsigned char *); -EtherCAT_command_t *EtherCAT_logical_read_write(EtherCAT_master_t *, - unsigned int, - unsigned int, - unsigned char *); - -void EtherCAT_remove_command(EtherCAT_master_t *, EtherCAT_command_t *); -#endif - -// Slave states -int EtherCAT_state_change(EtherCAT_master_t *, EtherCAT_slave_t *, unsigned char); - -/***************************************************************/ - // Private functions -#if 0 -EtherCAT_command_t *alloc_cmd(EtherCAT_master_t *); -int add_command(EtherCAT_master_t *, EtherCAT_command_t *); -#endif void set_byte(unsigned char *, unsigned int, unsigned char); void set_word(unsigned char *, unsigned int, unsigned int); void output_debug_data(unsigned char *, unsigned int); diff -r f04e93b8af0f -r 1b5aea4d5147 drivers/ec_types.c --- a/drivers/ec_types.c Fri Nov 18 09:35:04 2005 +0000 +++ b/drivers/ec_types.c Fri Nov 18 09:51:50 2005 +0000 @@ -143,7 +143,7 @@ unsigned int slave_idents_count = 7; -struct slave_ident slave_idents[] = +struct slave_ident slave_idents[] = { {0x00000002, 0x03F63052, Beckhoff_EL1014}, {0x00000002, 0x044C2C52, Beckhoff_EK1100},