etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:b3858d25ba4b
+:5d8281f1aa2a
 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);
 }
 }
 /*****************************************************************************/
 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) {
 }
 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];
 }
 void ec_master_sync_io(ec_master_t *master /**< EtherCAT master */)
 {
 ec_datagram_t *datagram, *n;
 unsigned int datagrams_sent;
-cycles_t t_start, t_end, t_timeout;
+cycles_t cycles_start, cycles_end, cycles_timeout;
 // send datagrams
 ecrt_master_send(master);
-t_start = get_cycles(); // measure io time
+cycles_start = get_cycles(); // measure io time
-t_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
+cycles_timeout = (cycles_t) EC_IO_TIMEOUT * (cpu_khz / 1000);
 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 (t_end - t_start >= t_timeout) break; // timeout!
+if (cycles_end - cycles_start >= cycles_timeout) break; // timeout!
 datagrams_sent = 0;
 list_for_each_entry_safe(datagram, n, &master->datagram_queue, queue) {
 if (datagram->state == EC_DATAGRAM_RECEIVED)
 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;
 }
 }
 /*****************************************************************************/

changeset 344	5d8281f1aa2a
parent 341	f8aa65e05ff4
child 345	beb0a77d73c0