etherlabmaster: comparison drivers/ec

equal deleted inserted replaced

-:98acc19c7594
+:b0a7a4745bf9
 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;
 for (i = 0; i < ECAT_COMMAND_RING_SIZE; i++)
 {
 EtherCAT_command_init(&master->cmd_ring[i]);
+master->cmd_reserved[i] = 0;
 }
 return 0;
 }
 @param master Zeiger auf den zu löschenden Master
 */
 void EtherCAT_master_clear(EtherCAT_master_t *master)
 {
-EC_DBG("Master clear");
 // Remove all pending commands
 while (master->first_command)
 {
 EtherCAT_remove_command(master, master->first_command);
 }
 kfree(master->process_data);
 master->process_data = NULL;
 }
 master->process_data_length = 0;
-EC_DBG("done...\n");
 }
 /***************************************************************/
 /**
 unsigned int wait_cycles;
 int i;
 // Send all commands
-//EC_DBG("Master async send");
 for (i = 0; i < ECAT_NUM_RETRIES; i++)
 {
 ASYNC = 1;
-if (EtherCAT_send(master) < 0) return -1;
+if (EtherCAT_send(master) < 0)
+{
+return -1;
+}
 ASYNC = 0;
 // Wait until something is received or an error has occurred
 wait_cycles = 10;
 while (master->dev->state == ECAT_DS_SENT && wait_cycles)
 {
 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 (ASYNC && framelength > 46)
+if (master->debug_level > 0)
-EC_DBG(KERN_WARNING "Framelength: %d", framelength);
+{
+EC_DBG(KERN_DEBUG "framelength: %i\n", framelength);
-if (ASYNC && cmdcnt > 1)
+}
-EC_DBG(KERN_WARNING "CMDcount: %d", cmdcnt);
 master->tx_data[0] = length & 0xFF;
 master->tx_data[1] = ((length & 0x700) >> 8) | 0x10;
 pos = 2;
 {
 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;
 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("%02X ", master->tx_data[i]);
 if ((i + 1) % 16 == 0) EC_DBG("\n" KERN_DEBUG);
 }
 EC_DBG("\n");
 return -1;
+}
+if (master->debug_level > 0)
+{
+EC_DBG(KERN_DEBUG "EtherCAT_send done.\n");
 }
 return 0;
 }
 EtherCAT_command_init(cmd)
 #define ECAT_FUNC_WRITE_FOOTER \
 cmd->data_length = length; \
 memcpy(cmd->data, data, length); \
-add_command(master, cmd); \
+if (add_command(master, cmd) < 0) return NULL; \
 return cmd
 #define ECAT_FUNC_READ_FOOTER \
 cmd->data_length = length; \
-add_command(master, cmd); \
+if (add_command(master, cmd) < 0) return NULL; \
 return cmd
 /***************************************************************/
 /**
 int j;
 for (j = 0; j < ECAT_COMMAND_RING_SIZE; j++) // Einmal rum suchen
 {
 // Solange suchen, bis freies Kommando gefunden
-if (master->cmd_ring[master->cmd_ring_index].reserved == 0)
+if (master->cmd_reserved[master->cmd_ring_index] == 0)
 {
-master->cmd_ring[master->cmd_ring_index].reserved = 1; // Belegen
+master->cmd_reserved[master->cmd_ring_index] = 1; // Belegen
+if (master->debug_level)
+{
+EC_DBG(KERN_DEBUG "Allocating command %i (addr %X).\n",
+master->cmd_ring_index,
+(int) &master->cmd_ring[master->cmd_ring_index]);
+}
 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;
 }
 @param master EtherCAT-Master
 @param cmd Zeiger auf das einzufügende Kommando
 */
-void add_command(EtherCAT_master_t *master,
+int add_command(EtherCAT_master_t *master,
-EtherCAT_command_t *cmd)
+EtherCAT_command_t *new_cmd)
 {
-EtherCAT_command_t **last_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");
+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 = cmd;
+*last_cmd = new_cmd;
+return 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;
 }
 {
 unsigned int i;
 for (i = 0; i < master->slave_count; i++)
 {
-EC_DBG("Activate Slave: %d\n",i);
 if (EtherCAT_activate_slave(master, &master->slaves[i]) < 0)
 {
 return -1;
 }
-EC_DBG("done...\n");
 }
 return 0;
 }
 unsigned int i;
 int ret = 0;
 for (i = 0; i < master->slave_count; i++)
 {
-EC_DBG("Deactivate Slave: %d\n",i);
 if (EtherCAT_deactivate_slave(master, &master->slaves[i]) < 0)
 {
 ret = -1;
 }
-EC_DBG("done...\n");
 }
 return ret;
 }
 EtherCAT_command_clear(master->process_data_command);
 master->process_data_command = NULL;
 }
 if ((master->process_data_command
-= EtherCAT_logical_read_write(master, 0,
+= EtherCAT_logical_read_write(master,
-master->process_data_length,
+0, master->process_data_length,
 master->process_data)) == NULL)
 {
 EC_DBG(KERN_ERR "EtherCAT: Could not allocate process data command!\n");
 return -1;
 }
 }
 /***************************************************************/
 /**
+Verwirft ein zuvor gesendetes Prozessdatenkommando.
+Diese Funktion sollte nach Ende des zyklischen Betriebes
+aufgerufen werden, um das noch wartende Prozessdaten-Kommando
+zu entfernen.
+@param master EtherCAT-Master
+*/
+void EtherCAT_clear_process_data(EtherCAT_master_t *master)
+{
+if (!master->process_data_command) return;
+EtherCAT_remove_command(master, master->process_data_command);
+EtherCAT_command_clear(master->process_data_command);
+master->process_data_command = NULL;
+}
+/***************************************************************/
+/**
 Setzt einen Byte-Wert im Speicher.
 @param data Startadresse
 @param offset Byte-Offset
 @param value Wert

changeset 2	b0a7a4745bf9
parent 0	05c992bf5847
child 5	6f2508af550c