etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:048c7310279c
+:42ed27ae6785
 ec_master_clear_slaves(master);
 // empty datagram queue
 list_for_each_entry_safe(datagram, next_c,
 &master->datagram_queue, queue) {
+datagram->state = EC_DATAGRAM_ERROR;
 list_del_init(&datagram->queue);
-datagram->state = EC_DATAGRAM_ERROR;
 }
 // clear domains
 list_for_each_entry_safe(domain, next_d, &master->domains, list) {
 list_del(&domain->list);
 master->datagram_index = 0;
 master->debug_level = 0;
 master->stats.timeouts = 0;
-master->stats.delayed = 0;
 master->stats.corrupted = 0;
 master->stats.skipped = 0;
 master->stats.unmatched = 0;
-master->stats.t_last = 0;
+master->stats.output_jiffies = 0;
 master->mode = EC_MASTER_MODE_ORPHANED;
 master->request_cb = NULL;
 master->release_cb = NULL;
 {
 ec_datagram_t *datagram;
 size_t datagram_size;
 uint8_t *frame_data, *cur_data;
 void *follows_word;
-cycles_t t_start, t_end;
+cycles_t cycles_start, cycles_end;
 unsigned int frame_count, more_datagrams_waiting;
 frame_count = 0;
-t_start = get_cycles();
+cycles_start = get_cycles();
 if (unlikely(master->debug_level > 1))
 EC_DBG("ec_master_send_datagrams\n");
 do {
 more_datagrams_waiting = 1;
 break;
 }
 datagram->state = EC_DATAGRAM_SENT;
-datagram->t_sent = t_start;
+datagram->cycles_sent = cycles_start;
 datagram->index = master->datagram_index++;
 if (unlikely(master->debug_level > 1))
 EC_DBG("adding datagram 0x%02X\n", datagram->index);
 frame_count++;
 }
 while (more_datagrams_waiting);
 if (unlikely(master->debug_level > 1)) {
-t_end = get_cycles();
+cycles_end = get_cycles();
 EC_DBG("ec_master_send_datagrams sent %i frames in %ius.\n",
-frame_count, (unsigned int) (t_end - t_start) * 1000 / cpu_khz);
+frame_count,
+(unsigned int) (cycles_end - cycles_start) * 1000 / cpu_khz);
 }
 }
 /*****************************************************************************/
 ec_master_output_stats(master);
 cur_data += data_size + EC_DATAGRAM_FOOTER_SIZE;
 continue;
 }
-// copy received data in the datagram memory
+// copy received data into the datagram memory
 memcpy(datagram->data, cur_data, data_size);
 cur_data += data_size;
 // set the datagram's working counter
 datagram->working_counter = EC_READ_U16(cur_data);
 necessary. The output happens at most once a second.
 */
 void ec_master_output_stats(ec_master_t *master /**< EtherCAT master */)
 {
-cycles_t t_now = get_cycles();
+if (unlikely(jiffies - master->stats.output_jiffies >= HZ)) {
+master->stats.output_jiffies = jiffies;
-if (unlikely((u32) (t_now - master->stats.t_last) / cpu_khz > 1000)) {
 if (master->stats.timeouts) {
 EC_WARN("%i datagrams TIMED OUT!\n", master->stats.timeouts);
 master->stats.timeouts = 0;
 }
-if (master->stats.delayed) {
-EC_WARN("%i frame(s) DELAYED!\n", master->stats.delayed);
-master->stats.delayed = 0;
-}
 if (master->stats.corrupted) {
 EC_WARN("%i frame(s) CORRUPTED!\n", master->stats.corrupted);
 master->stats.corrupted = 0;
 }
 if (master->stats.skipped) {
 }
 if (master->stats.unmatched) {
 EC_WARN("%i datagram(s) UNMATCHED!\n", master->stats.unmatched);
 master->stats.unmatched = 0;
 }
-master->stats.t_last = t_now;
 }
 }
 /*****************************************************************************/
 */
 void ec_master_idle_run(void *data /**< master pointer */)
 {
 ec_master_t *master = (ec_master_t *) data;
-cycles_t start, end;
+cycles_t cycles_start, cycles_end;
 // aquire master lock
 spin_lock_bh(&master->internal_lock);
-start = get_cycles();
+cycles_start = get_cycles();
 ecrt_master_receive(master);
 // execute master state machine
 ec_fsm_execute(&master->fsm);
 ecrt_master_send(master);
-end = get_cycles();
+cycles_end = get_cycles();
 // release master lock
 spin_unlock_bh(&master->internal_lock);
 master->idle_cycle_times[master->idle_cycle_time_pos]
-= (u32) (end - start) * 1000 / cpu_khz;
+= (u32) (cycles_end - cycles_start) * 1000 / cpu_khz;
 master->idle_cycle_time_pos++;
 master->idle_cycle_time_pos %= HZ;
 if (master->mode == EC_MASTER_MODE_IDLE)
 queue_delayed_work(master->workqueue, &master->idle_work, 1);
 void ec_master_eoe_run(unsigned long data /**< master pointer */)
 {
 ec_master_t *master = (ec_master_t *) data;
 ec_eoe_t *eoe;
 unsigned int active = 0;
-cycles_t start, end;
+cycles_t cycles_start, cycles_end;
+unsigned long restart_jiffies;
 list_for_each_entry(eoe, &master->eoe_handlers, list) {
 if (ec_eoe_active(eoe)) active++;
 }
 if (!active) goto queue_timer;
 spin_lock(&master->internal_lock);
 }
 else
 goto queue_timer;
-// actual EoE stuff
+// actual EoE processing
-start = get_cycles();
+cycles_start = get_cycles();
 ecrt_master_receive(master);
 list_for_each_entry(eoe, &master->eoe_handlers, list) {
 ec_eoe_run(eoe);
 }
 ecrt_master_send(master);
-end = get_cycles();
+cycles_end = get_cycles();
 // release lock...
 if (master->mode == EC_MASTER_MODE_OPERATION) {
 master->release_cb(master->cb_data);
 }
 else if (master->mode == EC_MASTER_MODE_IDLE) {
 spin_unlock(&master->internal_lock);
 }
 master->eoe_cycle_times[master->eoe_cycle_time_pos]
-= (u32) (end - start) * 1000 / cpu_khz;
+= (u32) (cycles_end - cycles_start) * 1000 / cpu_khz;
 master->eoe_cycle_time_pos++;
 master->eoe_cycle_time_pos %= HZ;
 queue_timer:
-master->eoe_timer.expires += HZ / EC_EOE_FREQUENCY;
+restart_jiffies = HZ / EC_EOE_FREQUENCY;
+if (!restart_jiffies) restart_jiffies = 1;
+master->eoe_timer.expires += restart_jiffies;
 add_timer(&master->eoe_timer);
 }
 /*****************************************************************************/
 */
 void ec_master_measure_bus_time(ec_master_t *master)
 {
 ec_datagram_t datagram;
-cycles_t t_start, t_end, t_timeout;
+cycles_t cycles_start, cycles_end, cycles_timeout;
 uint32_t times[100], sum, min, max, i;
 ec_datagram_init(&datagram);
 if (ec_datagram_brd(&datagram, 0x130, 2)) {
 EC_ERR("Failed to allocate datagram for bus time measuring.\n");
 ec_datagram_clear(&datagram);
 return;
 }
-t_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
+cycles_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
 sum = 0;
 min = 0xFFFFFFFF;
 max = 0;
 for (i = 0; i < 100; i++) {
 ec_master_queue_datagram(master, &datagram);
 ecrt_master_send(master);
-t_start = get_cycles();
+cycles_start = get_cycles();
 while (1) { // active waiting
 ec_device_call_isr(master->device);
-t_end = get_cycles(); // take current time
+cycles_end = get_cycles(); // take current time
 if (datagram.state == EC_DATAGRAM_RECEIVED) {
 break;
 }
 else if (datagram.state == EC_DATAGRAM_ERROR) {
 EC_WARN("Failed to measure bus time.\n");
 goto error;
 }
-else if (t_end - t_start >= t_timeout) {
+else if (cycles_end - cycles_start >= cycles_timeout) {
 EC_WARN("Timeout while measuring bus time.\n");
 goto error;
 }
 }
-times[i] = (unsigned int) (t_end - t_start) * 1000 / cpu_khz;
+times[i] = (unsigned int) (cycles_end - cycles_start) * 1000 / cpu_khz;
 sum += times[i];
 if (times[i] > max) max = times[i];
 if (times[i] < min) min = times[i];
 }
 Sends queued datagrams and waits for their reception.
 */
 void ec_master_sync_io(ec_master_t *master /**< EtherCAT master */)
 {
-ec_datagram_t *datagram, *n;
+ec_datagram_t *datagram;
-unsigned int datagrams_sent;
+unsigned int datagrams_waiting;
-cycles_t t_start, t_end, t_timeout;
 // send datagrams
 ecrt_master_send(master);
-t_start = get_cycles(); // measure io time
-t_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
 while (1) { // active waiting
-ec_device_call_isr(master->device);
+ecrt_master_receive(master); // receive and dequeue datagrams
-t_end = get_cycles(); // take current time
+// count number of datagrams still waiting for response
-if (t_end - t_start >= t_timeout) break; // timeout!
+datagrams_waiting = 0;
+list_for_each_entry(datagram, &master->datagram_queue, queue) {
-datagrams_sent = 0;
+datagrams_waiting++;
-list_for_each_entry_safe(datagram, n, &master->datagram_queue, queue) {
+}
-if (datagram->state == EC_DATAGRAM_RECEIVED)
-list_del_init(&datagram->queue);
+// if there are no more datagrams waiting, abort loop.
-else if (datagram->state == EC_DATAGRAM_SENT)
+if (!datagrams_waiting) break;
-datagrams_sent++;
-}
-if (!datagrams_sent) break;
-}
-// timeout; dequeue all datagrams
-list_for_each_entry_safe(datagram, n, &master->datagram_queue, queue) {
-switch (datagram->state) {
-case EC_DATAGRAM_SENT:
-case EC_DATAGRAM_QUEUED:
-datagram->state = EC_DATAGRAM_TIMED_OUT;
-master->stats.timeouts++;
-ec_master_output_stats(master);
-break;
-case EC_DATAGRAM_RECEIVED:
-master->stats.delayed++;
-ec_master_output_stats(master);
-break;
-default:
-break;
-}
-list_del_init(&datagram->queue);
 }
 }
 /*****************************************************************************/
 */
 void ecrt_master_receive(ec_master_t *master /**< EtherCAT master */)
 {
 ec_datagram_t *datagram, *next;
-cycles_t t_received, t_timeout;
+cycles_t cycles_received, cycles_timeout;
 ec_device_call_isr(master->device);
-t_received = get_cycles();
+cycles_received = get_cycles();
-t_timeout = EC_IO_TIMEOUT * cpu_khz / 1000;
+cycles_timeout = EC_IO_TIMEOUT * cpu_khz / 1000;
-// dequeue all received datagrams
-list_for_each_entry_safe(datagram, next, &master->datagram_queue, queue)
-if (datagram->state == EC_DATAGRAM_RECEIVED)
-list_del_init(&datagram->queue);
 // dequeue all datagrams that timed out
 list_for_each_entry_safe(datagram, next, &master->datagram_queue, queue) {
 switch (datagram->state) {
 case EC_DATAGRAM_SENT:
 case EC_DATAGRAM_QUEUED:
-if (t_received - datagram->t_sent > t_timeout) {
+if (cycles_received - datagram->cycles_sent > cycles_timeout) {
 list_del_init(&datagram->queue);
 datagram->state = EC_DATAGRAM_TIMED_OUT;
 master->stats.timeouts++;
 ec_master_output_stats(master);
 }
 */
 void ecrt_master_prepare(ec_master_t *master /**< EtherCAT master */)
 {
 ec_domain_t *domain;
-cycles_t t_start, t_end, t_timeout;
+cycles_t cycles_start, cycles_end, cycles_timeout;
 // queue datagrams of all domains
 list_for_each_entry(domain, &master->domains, list)
 ec_domain_queue(domain);
 ecrt_master_send(master);
-t_start = get_cycles(); // take sending time
+cycles_start = get_cycles(); // take sending time
-t_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
+cycles_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
 // active waiting
 while (1) {
-t_end = get_cycles();
+cycles_end = get_cycles();
-if (t_end - t_start >= t_timeout) break;
+if (cycles_end - cycles_start >= cycles_timeout) break;
 }
 }
 /*****************************************************************************/

branch	stable-1.1
changeset 1719	42ed27ae6785
parent 1716	9440f4ff25c7
child 1721	8d1fcfe68ced