etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:3e9155836bc7
+:8c0bc99229a9
 )
 {
 EC_INFO("Initializing master %i.\n", index);
 master->index = index;
-master->slaves = NULL;
 master->device = NULL;
 master->reserved = 0;
+INIT_LIST_HEAD(&master->slaves);
 INIT_LIST_HEAD(&master->command_queue);
 INIT_LIST_HEAD(&master->domains);
 INIT_LIST_HEAD(&master->eoe_slaves);
 // Init kobject and add it to the hierarchy
 void ec_master_reset(ec_master_t *master
 /**< Zeiger auf den zurückzusetzenden Master */
 )
 {
-unsigned int i;
+ec_slave_t *slave, *next_s;
 ec_command_t *command, *next_c;
 ec_domain_t *domain, *next_d;
 ec_eoe_t *eoe, *next_eoe;
 // Alle Slaves entfernen
-if (master->slaves) {
+list_for_each_entry_safe(slave, next_s, &master->slaves, list) {
-for (i = 0; i < master->slave_count; i++)
+list_del(&slave->list);
-ec_slave_clear(master->slaves + i);
+kobject_del(&slave->kobj);
-kfree(master->slaves);
+kobject_put(&slave->kobj);
-master->slaves = NULL;
 }
 master->slave_count = 0;
 // Kommando-Warteschlange leeren
 list_for_each_entry_safe(command, next_c, &master->command_queue, queue) {
+list_del_init(&command->queue);
 command->state = EC_CMD_ERROR;
-list_del_init(&command->queue);
 }
 // Domain-Liste leeren
 list_for_each_entry_safe(domain, next_d, &master->domains, list) {
 list_del(&domain->list);
 \return 0 bei Erfolg, sonst < 0
 */
 int ec_master_bus_scan(ec_master_t *master /**< EtherCAT-Master */)
 {
-ec_slave_t *slave;
+ec_slave_t *slave, *next;
 ec_slave_ident_t *ident;
 unsigned int i;
 ec_command_t *command;
 ec_eoe_t *eoe;
+uint16_t buscoupler_index, index_after_buscoupler;
-if (master->slaves || master->slave_count) {
+if (!list_empty(&master->slaves)) {
 EC_ERR("Slave scan already done!\n");
 return -1;
 }
 command = &master->simple_command;
 master->slave_count = command->working_counter;
 EC_INFO("Found %i slaves on bus.\n", master->slave_count);
 if (!master->slave_count) return 0;
-if (!(master->slaves = (ec_slave_t *)
-kmalloc(master->slave_count * sizeof(ec_slave_t), GFP_KERNEL))) {
-EC_ERR("Failed to allocate slaves!\n");
-return -1;
-}
 // Init slaves
 for (i = 0; i < master->slave_count; i++) {
-slave = master->slaves + i;
+if (!(slave = (ec_slave_t *) kmalloc(sizeof(ec_slave_t), GFP_KERNEL))) {
-ec_slave_init(slave, master);
+EC_ERR("Failed to allocate slave %i!\n", i);
-slave->ring_position = i;
+goto out_free;
-slave->station_address = i + 1;
+}
-}
+if (ec_slave_init(slave, master, i, i + 1)) goto out_free;
+if (kobject_add(&slave->kobj)) {
+EC_ERR("Failed to add kobject.\n");
+kobject_put(&slave->kobj); // free
+goto out_free;
+}
+list_add_tail(&slave->list, &master->slaves);
+}
+buscoupler_index = 0xFFFF;
+index_after_buscoupler = 0;
 // For every slave on the bus
-for (i = 0; i < master->slave_count; i++) {
+list_for_each_entry(slave, &master->slaves, list) {
-slave = master->slaves + i;
 // Write station address
-if (ec_command_apwr(command, slave->ring_position,
+if (ec_command_apwr(command, slave->ring_position, 0x0010,
-0x0010, sizeof(uint16_t))) return -1;
+sizeof(uint16_t))) goto out_free;
 EC_WRITE_U16(command->data, slave->station_address);
 if (unlikely(ec_master_simple_io(master, command))) {
-EC_ERR("Writing station address failed on slave %i!\n", i);
+EC_ERR("Writing station address failed on slave %i!\n",
-return -1;
+slave->ring_position);
+goto out_free;
 }
 // Fetch all slave information
-if (ec_slave_fetch(slave)) return -1;
+if (ec_slave_fetch(slave)) goto out_free;
 // Search for identification in "database"
 ident = slave_idents;
 while (ident->type) {
 if (unlikely(ident->vendor_id == slave->sii_vendor_id
 if (!slave->type)
 EC_WARN("Unknown slave device (vendor 0x%08X, code 0x%08X) at"
 " position %i.\n", slave->sii_vendor_id,
 slave->sii_product_code, i);
+else {
+if (slave->type->special == EC_TYPE_BUS_COUPLER) {
+buscoupler_index++;
+index_after_buscoupler = 0;
+}
+}
+slave->buscoupler_index = buscoupler_index;
+slave->index_after_buscoupler = index_after_buscoupler;
+index_after_buscoupler++;
 // Does the slave support EoE?
 if (slave->sii_mailbox_protocols & EC_MBOX_EOE) {
 if (!(eoe = (ec_eoe_t *) kmalloc(sizeof(ec_eoe_t), GFP_KERNEL))) {
 EC_ERR("Failed to allocate EoE-Object.\n");
-return -1;
+goto out_free;
 }
 ec_eoe_init(eoe, slave);
 list_add_tail(&eoe->list, &master->eoe_slaves);
 }
 }
 return 0;
+out_free:
+list_for_each_entry_safe(slave, next, &master->slaves, list) {
+list_del(&slave->list);
+kobject_del(&slave->kobj);
+kobject_put(&slave->kobj);
+}
+return -1;
 }
 /*****************************************************************************/
 /**
 const char *address /**< Address-String */
 )
 {
 unsigned long first, second;
 char *remainder, *remainder2;
-unsigned int i, alias_requested, alias_slave_index, alias_found;
+unsigned int alias_requested, alias_found;
-int coupler_idx, slave_idx;
+ec_slave_t *alias_slave = NULL, *slave;
-ec_slave_t *slave;
 if (!address || address[0] == 0) return NULL;
 alias_requested = 0;
-alias_slave_index = 0;
 if (address[0] == '#') {
 alias_requested = 1;
 address++;
 }
 return NULL;
 }
 if (alias_requested) {
 alias_found = 0;
-for (i = 0; i < master->slave_count; i++) {
+list_for_each_entry(alias_slave, &master->slaves, list) {
-if (master->slaves[i].sii_alias == first) {
+if (alias_slave->sii_alias == first) {
-alias_slave_index = i;
 alias_found = 1;
 break;
 }
 }
 if (!alias_found) {
 }
 }
 if (!remainder[0]) { // absolute position
 if (alias_requested) {
-return master->slaves + alias_slave_index;
+return alias_slave;
 }
 else {
-if (first < master->slave_count) {
+list_for_each_entry(slave, &master->slaves, list) {
-return master->slaves + first;
+if (slave->ring_position == first) return slave;
 }
 EC_ERR("Slave address \"%s\" - Absolute position invalid!\n",
 address);
 }
 }
 EC_ERR("Slave address \"%s\" - Invalid trailer!\n", address);
 return NULL;
 }
 if (alias_requested) {
-for (i = alias_slave_index + 1; i < master->slave_count; i++) {
+list_for_each_entry(slave, &master->slaves, list) {
-slave = master->slaves + i;
+if (slave->buscoupler_index == alias_slave->buscoupler_index
-if (!slave->type ||
+&& alias_slave->index_after_buscoupler == 0
-slave->type->special == EC_TYPE_BUS_COUPLER) break;
+&& slave->index_after_buscoupler == second)
-if (i - alias_slave_index == second) return slave;
+return slave;
 }
 EC_ERR("Slave address \"%s\" - Bus coupler %i has no %lu. slave"
-" following!\n", address,
+" following!\n", address, alias_slave->ring_position,
-(master->slaves + alias_slave_index)->ring_position,
 second);
 return NULL;
 }
 else {
-coupler_idx = -1;
+list_for_each_entry(slave, &master->slaves, list) {
-slave_idx = 0;
+if (slave->buscoupler_index == first
-for (i = 0; i < master->slave_count; i++, slave_idx++) {
+&& slave->index_after_buscoupler == second) return slave;
-slave = master->slaves + i;
-if (!slave->type) continue;
-if (slave->type->special == EC_TYPE_BUS_COUPLER) {
-coupler_idx++;
-slave_idx = 0;
-}
-if (coupler_idx == first && slave_idx == second) return slave;
 }
 }
 }
 else
 EC_ERR("Slave address \"%s\" - Invalid format!\n", address);
 \return 0 bei Erfolg, sonst < 0
 */
 int ecrt_master_activate(ec_master_t *master /**< EtherCAT-Master */)
 {
-unsigned int i, j;
+unsigned int j;
 ec_slave_t *slave;
 ec_command_t *command;
 const ec_sync_t *sync;
 const ec_slave_type_t *type;
 const ec_fmmu_t *fmmu;
 }
 domain_offset += domain->data_size;
 }
 // Slaves aktivieren
-for (i = 0; i < master->slave_count; i++) {
+list_for_each_entry(slave, &master->slaves, list) {
-slave = master->slaves + i;
 // Change state to INIT
 if (unlikely(ec_slave_state_change(slave, EC_SLAVE_STATE_INIT)))
 return -1;
 // Check if slave was registered...
 type = slave->type;
-if (!type) EC_WARN("Slave %i has unknown type!\n", i);
+if (!type)
+EC_WARN("Slave %i has unknown type!\n", slave->ring_position);
 // Check and reset CRC fault counters
 ec_slave_check_crc(slave);
 // Resetting FMMUs
 */
 void ecrt_master_deactivate(ec_master_t *master /**< EtherCAT-Master */)
 {
 ec_slave_t *slave;
-unsigned int i;
+list_for_each_entry(slave, &master->slaves, list) {
-for (i = 0; i < master->slave_count; i++)
-{
-slave = master->slaves + i;
 ec_slave_check_crc(slave);
 ec_slave_state_change(slave, EC_SLAVE_STATE_INIT);
 }
 }
 */
 int ecrt_master_fetch_sdo_lists(ec_master_t *master /**< EtherCAT-Master */)
 {
 ec_slave_t *slave;
-unsigned int i;
+list_for_each_entry(slave, &master->slaves, list) {
-for (i = 0; i < master->slave_count; i++) {
-slave = master->slaves + i;
 if (slave->sii_mailbox_protocols & EC_MBOX_COE) {
 if (unlikely(ec_slave_fetch_sdo_list(slave))) {
 EC_ERR("Failed to fetch SDO list on slave %i!\n",
 slave->ring_position);
 return -1;
 void ecrt_master_print(const ec_master_t *master, /**< EtherCAT-Master */
 unsigned int verbosity /**< Geschwätzigkeit */
 )
 {
-unsigned int i;
+ec_slave_t *slave;
 ec_eoe_t *eoe;
 EC_INFO("*** Begin master information ***\n");
 if (master->slave_count) {
 EC_INFO("Slave list:\n");
-for (i = 0; i < master->slave_count; i++)
+list_for_each_entry(slave, &master->slaves, list)
-ec_slave_print(&master->slaves[i], verbosity);
+ec_slave_print(slave, verbosity);
 }
 if (!list_empty(&master->eoe_slaves)) {
 EC_INFO("Ethernet-over-EtherCAT (EoE) objects:\n");
 list_for_each_entry(eoe, &master->eoe_slaves, list) {
 ec_eoe_print(eoe);

changeset 182	8c0bc99229a9
parent 179	fb4c9dd11ca0
child 184	2fc86cec12df