master/master.c
changeset 335 1e37c856b74e
parent 334 2be97e069602
child 336 360e5287c888
equal deleted inserted replaced
334:2be97e069602 335:1e37c856b74e
   118     master->eoe_timer.function = ec_master_eoe_run;
   118     master->eoe_timer.function = ec_master_eoe_run;
   119     master->eoe_timer.data = (unsigned long) master;
   119     master->eoe_timer.data = (unsigned long) master;
   120     master->internal_lock = SPIN_LOCK_UNLOCKED;
   120     master->internal_lock = SPIN_LOCK_UNLOCKED;
   121     master->eoe_running = 0;
   121     master->eoe_running = 0;
   122     master->eoe_checked = 0;
   122     master->eoe_checked = 0;
   123     master->idle_cycle_time = 0;
   123     for (i = 0; i < HZ; i++) {
   124     master->eoe_cycle_time = 0;
   124         master->idle_cycle_times[i] = 0;
       
   125         master->eoe_cycle_times[i] = 0;
       
   126     }
       
   127     master->idle_cycle_time_pos = 0;
       
   128     master->eoe_cycle_time_pos = 0;
   125 
   129 
   126     // create workqueue
   130     // create workqueue
   127     if (!(master->workqueue = create_singlethread_workqueue("EtherCAT"))) {
   131     if (!(master->workqueue = create_singlethread_workqueue("EtherCAT"))) {
   128         EC_ERR("Failed to create master workqueue.\n");
   132         EC_ERR("Failed to create master workqueue.\n");
   129         goto out_return;
   133         goto out_return;
   621     end = get_cycles();
   625     end = get_cycles();
   622 
   626 
   623     // release master lock
   627     // release master lock
   624     spin_unlock_bh(&master->internal_lock);
   628     spin_unlock_bh(&master->internal_lock);
   625 
   629 
   626     master->idle_cycle_time = (u32) (end - start) * 1000 / cpu_khz;
   630     master->idle_cycle_times[master->idle_cycle_time_pos]
       
   631         = (u32) (end - start) * 1000 / cpu_khz;
       
   632     master->idle_cycle_time_pos++;
       
   633     master->idle_cycle_time_pos %= HZ;
   627 
   634 
   628     if (master->mode == EC_MASTER_MODE_IDLE)
   635     if (master->mode == EC_MASTER_MODE_IDLE)
   629         queue_delayed_work(master->workqueue, &master->idle_work, 1);
   636         queue_delayed_work(master->workqueue, &master->idle_work, 1);
   630 }
   637 }
   631 
   638 
   698 ssize_t ec_master_info(ec_master_t *master, /**< EtherCAT master */
   705 ssize_t ec_master_info(ec_master_t *master, /**< EtherCAT master */
   699                        char *buffer /**< memory to store data */
   706                        char *buffer /**< memory to store data */
   700                        )
   707                        )
   701 {
   708 {
   702     off_t off = 0;
   709     off_t off = 0;
       
   710     uint32_t cur, sum, min, max, pos, i;
   703 
   711 
   704     off += sprintf(buffer + off, "\nMode: ");
   712     off += sprintf(buffer + off, "\nMode: ");
   705     switch (master->mode) {
   713     switch (master->mode) {
   706         case EC_MASTER_MODE_ORPHANED:
   714         case EC_MASTER_MODE_ORPHANED:
   707             off += sprintf(buffer + off, "ORPHANED");
   715             off += sprintf(buffer + off, "ORPHANED");
       
   716             break;
   708         case EC_MASTER_MODE_IDLE:
   717         case EC_MASTER_MODE_IDLE:
   709             off += sprintf(buffer + off, "IDLE");
   718             off += sprintf(buffer + off, "IDLE");
       
   719             break;
   710         case EC_MASTER_MODE_OPERATION:
   720         case EC_MASTER_MODE_OPERATION:
   711             off += sprintf(buffer + off, "OPERATION");
   721             off += sprintf(buffer + off, "OPERATION");
       
   722             break;
   712     }
   723     }
   713 
   724 
   714     off += sprintf(buffer + off, "\n\nNumber of slaves: %i\n",
   725     off += sprintf(buffer + off, "\n\nNumber of slaves: %i\n",
   715                    master->slave_count);
   726                    master->slave_count);
   716 
   727 
   717     off += sprintf(buffer + off, "\nTiming [us]:\n");
   728     off += sprintf(buffer + off, "\nTiming (min/avg/max) [us]:\n");
   718     off += sprintf(buffer + off, "  Idle cycle time: %u\n",
   729 
   719                    master->idle_cycle_time);
   730     sum = 0;
   720     off += sprintf(buffer + off, "  EoE cycle time: %u\n",
   731     min = 0xFFFFFFFF;
   721                    master->eoe_cycle_time);
   732     max = 0;
       
   733     pos = master->idle_cycle_time_pos;
       
   734     for (i = 0; i < HZ; i++) {
       
   735         cur = master->idle_cycle_times[(i + pos) % HZ];
       
   736         sum += cur;
       
   737         if (cur < min) min = cur;
       
   738         if (cur > max) max = cur;
       
   739     }
       
   740     off += sprintf(buffer + off, "  Idle cycle: %u / %u.%u / %u\n",
       
   741                    min, sum / HZ, (sum * 100 / HZ) % 100, max);
       
   742 
       
   743     sum = 0;
       
   744     min = 0xFFFFFFFF;
       
   745     max = 0;
       
   746     pos = master->eoe_cycle_time_pos;
       
   747     for (i = 0; i < HZ; i++) {
       
   748         cur = master->eoe_cycle_times[(i + pos) % HZ];
       
   749         sum += cur;
       
   750         if (cur < min) min = cur;
       
   751         if (cur > max) max = cur;
       
   752     }
       
   753     off += sprintf(buffer + off, "  EoE cycle: %u / %u.%u / %u\n",
       
   754                    min, sum / HZ, (sum * 100 / HZ) % 100, max);
   722 
   755 
   723     off += sprintf(buffer + off, "\n");
   756     off += sprintf(buffer + off, "\n");
   724 
   757 
   725     return off;
   758     return off;
   726 }
   759 }
   952     }
   985     }
   953     else if (master->mode == EC_MASTER_MODE_IDLE) {
   986     else if (master->mode == EC_MASTER_MODE_IDLE) {
   954         spin_unlock(&master->internal_lock);
   987         spin_unlock(&master->internal_lock);
   955     }
   988     }
   956 
   989 
   957     master->eoe_cycle_time = (u32) (end - start) * 1000 / cpu_khz;
   990     master->eoe_cycle_times[master->eoe_cycle_time_pos]
       
   991         = (u32) (end - start) * 1000 / cpu_khz;
       
   992     master->eoe_cycle_time_pos++;
       
   993     master->eoe_cycle_time_pos %= HZ;
   958 
   994 
   959  queue_timer:
   995  queue_timer:
   960     master->eoe_timer.expires += HZ / EC_EOE_FREQUENCY;
   996     master->eoe_timer.expires += HZ / EC_EOE_FREQUENCY;
   961     add_timer(&master->eoe_timer);
   997     add_timer(&master->eoe_timer);
   962 }
   998 }