etherlabmaster: comparison drivers/ec

equal deleted inserted replaced

-:a5c18da4e781
+:f2ebe943c686
 {
 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;
 }
 if ((cmd = EtherCAT_broadcast_read(master, 0x0000, 4)) == NULL)
 {
 return -1;
 }
 if (EtherCAT_async_send_receive(master) != 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);
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 else
 {
 EC_DBG("EtherCAT: Found all %i slaves.\n", slave_count);
 }
 EtherCAT_remove_command(master, cmd);
 // For every slave in the list
 for (i = 0; i < slave_count; i++)
 {
 cur = &slaves[i];
 // 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;
 if ((cmd = EtherCAT_position_write(master, cur->ring_position, 0x0010, 2, data)) == NULL)
 {
 return -1;
 }
 if (EtherCAT_async_send_receive(master) != 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;
 }
 EtherCAT_remove_command(master, cmd);
 // Read base data
 if ((cmd = EtherCAT_read(master, cur->station_address, 0x0000, 4)) == NULL)
 {
 }
 if (EtherCAT_async_send_receive(master) != 0)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Could not send command!\n");
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 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);
 EtherCAT_remove_command(master, cmd);
 // Read identification from "Slave Information Interface" (SII)
 if (EtherCAT_read_slave_information(master, cur->station_address,
 0x0008, &cur->vendor_id) != 0)
 {
 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++)
 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;
 {
 udelay(10);
 if ((cmd = EtherCAT_read(master, node_address, 0x502, 10)) == NULL)
 return -2;
 if (EtherCAT_async_send_receive(master) != 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -3;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: SII-read status - Slave %04X did not respond!\n",
 node_address);
 {
 memcpy(target, cmd->data + 6, 4);
 EtherCAT_remove_command(master, cmd);
 break;
 }
 EtherCAT_remove_command(master, cmd);
 tries_left--;
 }
 EC_DBG(KERN_ERR "EtherCAT: Received corrupted frame (illegal length)!\n");
 EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n");
 EC_DBG(KERN_DEBUG);
 for (i = 0; i < master->tx_data_length; 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 "EtherCAT: rx_data content:\n");
 EC_DBG(KERN_DEBUG);
 EC_DBG(KERN_ERR "EtherCAT: Received corrupted frame (length does not match)!\n");
 EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n");
 EC_DBG(KERN_DEBUG);
 for (i = 0; i < master->tx_data_length; 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 "EtherCAT: rx_data content:\n");
 EC_DBG(KERN_DEBUG);
 EC_DBG(KERN_ERR "EtherCAT: Received frame with incomplete command header!\n");
 EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n");
 EC_DBG(KERN_DEBUG);
 for (i = 0; i < master->tx_data_length; 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 "EtherCAT: rx_data content:\n");
 EC_DBG(KERN_DEBUG);
 EC_DBG(KERN_ERR "EtherCAT: Received frame with incomplete command data!\n");
 EC_DBG(KERN_DEBUG "EtherCAT: tx_data content:\n");
 EC_DBG(KERN_DEBUG);
 for (i = 0; i < master->tx_data_length; 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 "EtherCAT: rx_data content:\n");
 EC_DBG(KERN_DEBUG);
 @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,
 @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,
 @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,
 @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,
 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,
 @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,
 @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,
 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
 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)
 @param master EtherCAT-Master
 @param slave Slave, dessen Zustand geändert werden soll
 @param state_and_ack Neuer Zustand, evtl. mit gesetztem
 Acknowledge-Flag
 @return 0 bei Erfolg, sonst < 0
 */
 int EtherCAT_state_change(EtherCAT_master_t *master,
 EtherCAT_slave_t *slave,
 }
 if (EtherCAT_async_send_receive(master) != 0)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Could not set state %02X - Unable to send!\n", state_and_ack);
 return -2;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Could not set state %02X - Device did not respond!\n", state_and_ack);
 return -3;
 }
 EtherCAT_remove_command(master, cmd);
 slave->requested_state = state_and_ack & 0x0F;
 tries_left = 1000;
 0x0130, 2)) == NULL)
 {
 EC_DBG(KERN_ERR "EtherCAT: Could not check state %02X - Out of memory!\n", state_and_ack);
 return -1;
 }
 if (EtherCAT_async_send_receive(master) != 0)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Could not check state %02X - Unable to send!\n", state_and_ack);
 return -2;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(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
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(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
 {
 EtherCAT_remove_command(master, cmd);
 break;
 }
 EtherCAT_remove_command(master, cmd);
 tries_left--;
 }
 if (!tries_left)
 {
 setzt Sync-Manager und FMMU's, führt die entsprechenden
 Zustandsübergänge durch, bis der Slave betriebsbereit ist.
 @param master EtherCAT-Master
 @param slave Zu aktivierender Slave
 @return 0 bei Erfolg, sonst < 0
 */
 int EtherCAT_activate_slave(EtherCAT_master_t *master,
 EtherCAT_slave_t *slave)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Resetting FMMUs - Slave %04X did not respond!\n",
 slave->station_address);
 return -2;
 }
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Resetting SMs - Slave %04X did not respond!\n",
 slave->station_address);
 return -2;
 }
 {
 if (desc->sm0)
 {
 if ((cmd = EtherCAT_write(master, slave->station_address, 0x0800, 8, desc->sm0)) == NULL)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Setting SM0 - Slave %04X did not respond!\n",
 slave->station_address);
 return -3;
 }
 EtherCAT_remove_command(master, cmd);
 }
 if (desc->sm1)
 {
 if ((cmd = EtherCAT_write(master, slave->station_address, 0x0808, 8, desc->sm1)) == NULL)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Setting SM1 - Slave %04X did not respond!\n",
 slave->station_address);
 return -2;
 }
 EtherCAT_remove_command(master, cmd);
 }
 }
 // Change state to PREOP
 if (desc->fmmu0)
 {
 memcpy(fmmu, desc->fmmu0, 16);
 fmmu[0] = slave->logical_address0 & 0x000000FF;
 fmmu[1] = (slave->logical_address0 & 0x0000FF00) >> 8;
 fmmu[2] = (slave->logical_address0 & 0x00FF0000) >> 16;
 fmmu[3] = (slave->logical_address0 & 0xFF000000) >> 24;
 if ((cmd = EtherCAT_write(master, slave->station_address, 0x0600, 16, fmmu)) == NULL)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Setting FMMU0 - Slave %04X did not respond!\n",
 slave->station_address);
 return -2;
 }
 {
 if (desc->sm0)
 {
 if ((cmd = EtherCAT_write(master, slave->station_address, 0x0800, 8, desc->sm0)) == NULL)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Setting SM0 - Slave %04X did not respond!\n",
 slave->station_address);
 return -3;
 }
 EtherCAT_remove_command(master, cmd);
 }
 if (desc->sm1)
 {
 if ((cmd = EtherCAT_write(master, slave->station_address, 0x0808, 8, desc->sm1)) == NULL)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Setting SM1 - Slave %04X did not respond!\n",
 slave->station_address);
 return -3;
 }
 EtherCAT_remove_command(master, cmd);
 }
 }
 if (desc->sm2)
 {
 if ((cmd = EtherCAT_write(master, slave->station_address, 0x0810, 8, desc->sm2)) == NULL)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Setting SM2 - Slave %04X did not respond!\n",
 slave->station_address);
 return -3;
 }
 EtherCAT_remove_command(master, cmd);
 }
 if (desc->sm3)
 {
 if ((cmd = EtherCAT_write(master, slave->station_address, 0x0818, 8, desc->sm3)) == NULL)
 return -1;
 if (EtherCAT_async_send_receive(master) < 0)
 {
 EtherCAT_remove_command(master, cmd);
 return -1;
 }
 if (cmd->working_counter != 1)
 {
 EtherCAT_remove_command(master, cmd);
 EC_DBG(KERN_ERR "EtherCAT: Setting SM3 - Slave %04X did not respond!\n",
 slave->station_address);
 return -3;
 }
 EtherCAT_remove_command(master, cmd);
 }
 // Change state to SAVEOP
 if (EtherCAT_state_change(master, slave, ECAT_STATE_SAVEOP) != 0)
 /**
 Setzt einen Slave zurück in den Init-Zustand.
 @param master EtherCAT-Master
 @param slave Zu deaktivierender Slave
 @return 0 bei Erfolg, sonst < 0
 */
 int EtherCAT_deactivate_slave(EtherCAT_master_t *master,
 EtherCAT_slave_t *slave)
 Aktiviert alle Slaves.
 @see EtherCAT_activate_slave
 @param master EtherCAT-Master
 @return 0 bei Erfolg, sonst < 0
 */
 int EtherCAT_activate_all_slaves(EtherCAT_master_t *master)
 {
 Deaktiviert alle Slaves.
 @see EtherCAT_deactivate_slave
 @param master EtherCAT-Master
 @return 0 bei Erfolg, sonst < 0
 */
 int EtherCAT_deactivate_all_slaves(EtherCAT_master_t *master)
 {
 Erstellt ein "logical read write"-Kommando mit den
 Prozessdaten des Masters und sendet es an den Bus.
 @param master EtherCAT-Master
 @return 0 bei Erfolg, sonst < 0
 */
 int EtherCAT_write_process_data(EtherCAT_master_t *master)
 {
 Empfängt ein zuvor gesendetes "logical read write"-Kommando
 und kopiert die empfangenen daten in den Prozessdatenspeicher
 des Masters.
 @param master EtherCAT-Master
 @return 0 bei Erfolg, sonst < 0
 */
 int EtherCAT_read_process_data(EtherCAT_master_t *master)
 {

changeset 8	f2ebe943c686
parent 6	e36a85dc2730
child 11	e58d78234412