etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:c7e7d80e49ea
+:83e9160319ec
 )
 {
 ec_datagram_t *datagram, *next;
 size_t queue_size = 0;
-if (master->fsm_queue_lock_cb)
+if (master->fsm_queue_lock_cb) {
 master->fsm_queue_lock_cb(master->fsm_queue_locking_data);
+}
 if (ec_mutex_trylock(&master->fsm_queue_mutex) == 0) {
-if (master->fsm_queue_unlock_cb)
+goto unlock_cb;
-master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
+}
-return;
-}
 if (list_empty(&master->fsm_datagram_queue)) {
-ec_mutex_unlock(&master->fsm_queue_mutex);
+goto unlock;
-if (master->fsm_queue_unlock_cb)
+}
-master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
-return;
-}
 list_for_each_entry(datagram, &master->datagram_queue, queue) {
 queue_size += datagram->data_size;
 }
 list_for_each_entry_safe(datagram, next, &master->fsm_datagram_queue,
 datagram->data_size, queue_size);
 #endif
 #ifdef EC_HAVE_CYCLES
 datagram->cycles_sent = 0;
 #endif
-datagram->jiffies_sent = 0;
+datagram->jiffies_sent = 0; // FIXME why?
 ec_master_queue_datagram(master, datagram);
-}
+} else {
-else {
 if (datagram->data_size > master->max_queue_size) {
 list_del_init(&datagram->fsm_queue);
 datagram->state = EC_DATAGRAM_ERROR;
 EC_MASTER_ERR(master, "Fsm datagram %p is too large,"
 " size=%zu, max_queue_size=%zu\n",
 }
 #endif
 }
 }
 }
+unlock:
 ec_mutex_unlock(&master->fsm_queue_mutex);
-if (master->fsm_queue_unlock_cb)
+unlock_cb:
+if (master->fsm_queue_unlock_cb) {
 master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
+}
 }
 /*****************************************************************************/
 /** Sets the expected interval between calls to ecrt_master_send
 master->max_queue_size -= master->max_queue_size / 10;
 }
 /*****************************************************************************/
-/** Places an request (SDO/FoE/SoE/EoE) fsm datagram in the sdo datagram queue.
+/** Places an request (SDO/FoE/SoE/EoE) fsm datagram in the sdo datagram
+* queue.
 */
 void ec_master_queue_request_fsm_datagram(
 ec_master_t *master, /**< EtherCAT master */
 ec_datagram_t *datagram /**< datagram */
 )
 {
-ec_master_queue_fsm_datagram(master,datagram);
+ec_master_queue_fsm_datagram(master, datagram);
-master->fsm.idle = 0;   // pump the bus as fast as possible
+master->fsm.idle = 0; // pump the bus as fast as possible
 }
 /*****************************************************************************/
 /** Places an fsm datagram in the sdo datagram queue.
 ec_datagram_t *datagram /**< datagram */
 )
 {
 ec_datagram_t *queued_datagram;
-if (master->fsm_queue_lock_cb)
+if (master->fsm_queue_lock_cb) {
 master->fsm_queue_lock_cb(master->fsm_queue_locking_data);
+}
 ec_mutex_lock(&master->fsm_queue_mutex);
 // check, if the datagram is already queued
 list_for_each_entry(queued_datagram, &master->fsm_datagram_queue,
 fsm_queue) {
 if (queued_datagram == datagram) {
 datagram->state = EC_DATAGRAM_QUEUED;
-ec_mutex_unlock(&master->fsm_queue_mutex);
+goto unlock;
-if (master->fsm_queue_unlock_cb)
-master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
-return;
 }
 }
 #if DEBUG_INJECT
 EC_MASTER_DBG(master, 2, "Requesting fsm datagram %p size=%zu\n",
 list_add_tail(&datagram->fsm_queue, &master->fsm_datagram_queue);
 datagram->state = EC_DATAGRAM_QUEUED;
 #ifdef EC_HAVE_CYCLES
 datagram->cycles_sent = get_cycles();
 #endif
-datagram->jiffies_sent = jiffies;
+datagram->jiffies_sent = jiffies; // FIXME why?
+unlock:
 ec_mutex_unlock(&master->fsm_queue_mutex);
-if (master->fsm_queue_unlock_cb)
+if (master->fsm_queue_unlock_cb) {
 master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
+}
 }
 /*****************************************************************************/
 /** Places a datagram in the datagram queue.
 }
 list_add_tail(&datagram->sent, &sent_datagrams);
 datagram->index = master->datagram_index++;
-EC_MASTER_DBG(master, 2, "adding datagram %p i=0x%02X size=%zu\n",datagram,
+EC_MASTER_DBG(master, 2, "Adding datagram %p i=0x%02X size=%zu\n",
-datagram->index,datagram_size);
+datagram, datagram->index,datagram_size);
 // set "datagram following" flag in previous frame
-if (follows_word)
+if (follows_word) {
-EC_WRITE_U16(follows_word, EC_READ_U16(follows_word) | 0x8000);
+EC_WRITE_U16(follows_word,
+EC_READ_U16(follows_word) | 0x8000);
+}
 // EtherCAT datagram header
 EC_WRITE_U8 (cur_data,     datagram->type);
 EC_WRITE_U8 (cur_data + 1, datagram->index);
 memcpy(cur_data + 2, datagram->address, EC_ADDR_LEN);
 cur_data += EC_DATAGRAM_HEADER_SIZE;
 // EtherCAT datagram data
 frame_datagram_data = cur_data;
 if (datagram->domain) {
-unsigned int datagram_address = EC_READ_U32(datagram->address);
+unsigned int datagram_address =
+EC_READ_U32(datagram->address);
 int i = 0;
 uint8_t *domain_data = datagram->data;
-list_for_each_entry(domain_fmmu, &datagram->domain->fmmu_configs, list) {
+list_for_each_entry(domain_fmmu,
+&datagram->domain->fmmu_configs, list) {
 if (domain_fmmu->dir == EC_DIR_OUTPUT ) {
-unsigned int frame_offset = domain_fmmu->logical_start_address-datagram_address;
+unsigned int frame_offset =
-memcpy(frame_datagram_data+frame_offset, domain_data, domain_fmmu->data_size);
+domain_fmmu->logical_start_address
+- datagram_address;
+memcpy(frame_datagram_data+frame_offset, domain_data,
+domain_fmmu->data_size);
 if (unlikely(master->debug_level > 1)) {
-EC_DBG("sending dg %p i=0x%02X fmmu %u fp=%u dp=%zu size=%u\n",
+EC_DBG("sending dg %p i=0x%02X fmmu %u fp=%u"
-datagram,datagram->index, i,frame_offset,domain_data-datagram->data,domain_fmmu->data_size);
+" dp=%zu size=%u\n",
-ec_print_data(domain_data, domain_fmmu->data_size);
+datagram, datagram->index, i,
+frame_offset,
+domain_data - datagram->data,
+domain_fmmu->data_size);
+ec_print_data(domain_data,
+domain_fmmu->data_size);
 }
 }
 domain_data += domain_fmmu->data_size;
 ++i;
 }
-}
+} else {
-else {
+memcpy(frame_datagram_data, datagram->data,
-memcpy(frame_datagram_data, datagram->data, datagram->data_size);
+datagram->data_size);
 }
 cur_data += datagram->data_size;
 // EtherCAT datagram footer
 EC_WRITE_U16(cur_data, 0x0000); // reset working counter
 cur_data += data_size + EC_DATAGRAM_FOOTER_SIZE;
 continue;
 }
 frame_datagram_data = cur_data;
 if (datagram->domain) {
 size_t datagram_address = EC_READ_U32(datagram->address);
 int i = 0;
 uint8_t *domain_data = datagram->data;
-list_for_each_entry(domain_fmmu, &datagram->domain->fmmu_configs, list) {
-if (domain_fmmu->dir == EC_DIR_INPUT ) {
+list_for_each_entry(domain_fmmu, &datagram->domain->fmmu_configs,
-unsigned int frame_offset = domain_fmmu->logical_start_address-datagram_address;
+list) {
-memcpy(domain_data, frame_datagram_data+frame_offset, domain_fmmu->data_size);
+if (domain_fmmu->dir == EC_DIR_INPUT) {
+unsigned int frame_offset =
+domain_fmmu->logical_start_address - datagram_address;
+memcpy(domain_data, frame_datagram_data + frame_offset,
+domain_fmmu->data_size);
 if (unlikely(master->debug_level > 1)) {
-EC_DBG("receiving dg %p i=0x%02X fmmu %u fp=%u dp=%zu size=%u\n",
+EC_DBG("receiving dg %p i=0x%02X fmmu %u fp=%u"
-datagram,datagram->index, i,
+" dp=%zu size=%u\n",
-frame_offset,domain_data-datagram->data,domain_fmmu->data_size);
+datagram, datagram->index, i,
+frame_offset, domain_data - datagram->data,
+domain_fmmu->data_size);
 ec_print_data(domain_data, domain_fmmu->data_size);
 }
 }
 domain_data += domain_fmmu->data_size;
 ++i;
 }
-}
+} else {
-else {
 // copy received data into the datagram memory
 memcpy(datagram->data, frame_datagram_data, data_size);
 }
 cur_data += data_size;
 static int ec_master_idle_thread(void *priv_data)
 {
 ec_master_t *master = (ec_master_t *) priv_data;
 ec_slave_t *slave = NULL;
 size_t sent_bytes;
 // send interval in IDLE phase
 ec_master_set_send_interval(master, 1000000 / HZ);
 EC_MASTER_DBG(master, 1, "Idle thread running with send interval = %u us,"
 " max data size=%zu\n", master->send_interval,
 ec_mutex_lock(&master->io_mutex);
 ecrt_master_receive(master);
 ec_mutex_unlock(&master->io_mutex);
 // execute master & slave state machines
-if (ec_mutex_lock_interruptible(&master->master_mutex))
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 break;
+}
 if (ec_fsm_master_exec(&master->fsm)) {
 ec_master_mbox_queue_datagrams(master, &master->fsm_mbox);
 }
 for (slave = master->slaves;
 slave < master->slaves + master->slave_count;
 slave++) {
 ec_fsm_slave_exec(&slave->fsm); // may queue datagram in fsm queue
 }
 #if defined(EC_EOE)
-if (!ec_master_eoe_processing(master))
+if (!ec_master_eoe_processing(master)) {
-master->fsm.idle = 0;  // pump the bus as fast as possible
+master->fsm.idle = 0; // pump the bus as fast as possible
+}
 #endif
 ec_mutex_unlock(&master->master_mutex);
 // queue and send
 ec_mutex_lock(&master->io_mutex);
 // output statistics
 ec_master_output_stats(master);
 // execute master & slave state machines
-if (ec_mutex_lock_interruptible(&master->master_mutex))
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 break;
-if (ec_fsm_master_exec(&master->fsm))
+}
+if (ec_fsm_master_exec(&master->fsm)) {
 ec_master_mbox_queue_datagrams(master, &master->fsm_mbox);
+}
 for (slave = master->slaves;
 slave < master->slaves + master->slave_count;
 slave++) {
 ec_fsm_slave_exec(&slave->fsm); // may queue datagram in fsm queue
 }
 ec_master_inject_fsm_datagrams(master);
 if (unlikely(!master->main_device.link_state)) {
 // link is down, no datagram can be sent
-list_for_each_entry_safe(datagram, next, &master->datagram_queue, queue) {
+list_for_each_entry_safe(datagram, next, &master->datagram_queue,
+queue) {
 datagram->state = EC_DATAGRAM_ERROR;
 list_del_init(&datagram->queue);
 }
 // query link state

changeset 2094	83e9160319ec
parent 2084	eefccfa312ef
child 2095	53b5128e1313