80 const uint8_t *backup_mac, /**< MAC address of backup device */ |
80 const uint8_t *backup_mac, /**< MAC address of backup device */ |
81 dev_t device_number, /**< Character device number. */ |
81 dev_t device_number, /**< Character device number. */ |
82 struct class *class /**< Device class. */ |
82 struct class *class /**< Device class. */ |
83 ) |
83 ) |
84 { |
84 { |
85 unsigned int i; |
|
86 |
|
87 master->index = index; |
85 master->index = index; |
88 master->reserved = 0; |
86 master->reserved = 0; |
89 |
87 |
90 master->main_mac = main_mac; |
88 master->main_mac = main_mac; |
91 master->backup_mac = backup_mac; |
89 master->backup_mac = backup_mac; |
120 master->stats.corrupted = 0; |
118 master->stats.corrupted = 0; |
121 master->stats.unmatched = 0; |
119 master->stats.unmatched = 0; |
122 master->stats.output_jiffies = 0; |
120 master->stats.output_jiffies = 0; |
123 master->frames_timed_out = 0; |
121 master->frames_timed_out = 0; |
124 |
122 |
125 for (i = 0; i < HZ; i++) { |
123 #ifdef EC_EOE |
126 master->idle_cycle_times[i] = 0; |
|
127 #ifdef EC_EOE |
|
128 master->eoe_cycle_times[i] = 0; |
|
129 #endif |
|
130 } |
|
131 master->idle_cycle_time_pos = 0; |
|
132 #ifdef EC_EOE |
|
133 master->eoe_cycle_time_pos = 0; |
|
134 |
|
135 init_timer(&master->eoe_timer); |
124 init_timer(&master->eoe_timer); |
136 master->eoe_timer.function = ec_master_eoe_run; |
125 master->eoe_timer.function = ec_master_eoe_run; |
137 master->eoe_timer.data = (unsigned long) master; |
126 master->eoe_timer.data = (unsigned long) master; |
138 master->eoe_running = 0; |
127 master->eoe_running = 0; |
139 INIT_LIST_HEAD(&master->eoe_handlers); |
128 INIT_LIST_HEAD(&master->eoe_handlers); |
820 |
809 |
821 /** Master kernel thread function for IDLE phase. |
810 /** Master kernel thread function for IDLE phase. |
822 */ |
811 */ |
823 static int ec_master_idle_thread(ec_master_t *master) |
812 static int ec_master_idle_thread(ec_master_t *master) |
824 { |
813 { |
825 cycles_t cycles_start, cycles_end; |
|
826 |
|
827 daemonize("EtherCAT-IDLE"); |
814 daemonize("EtherCAT-IDLE"); |
828 allow_signal(SIGTERM); |
815 allow_signal(SIGTERM); |
829 |
816 |
830 while (!signal_pending(current)) { |
817 while (!signal_pending(current)) { |
831 cycles_start = get_cycles(); |
|
832 ec_datagram_output_stats(&master->fsm_datagram); |
818 ec_datagram_output_stats(&master->fsm_datagram); |
833 |
819 |
834 // receive |
820 // receive |
835 spin_lock_bh(&master->internal_lock); |
821 spin_lock_bh(&master->internal_lock); |
836 ecrt_master_receive(master); |
822 ecrt_master_receive(master); |
846 spin_lock_bh(&master->internal_lock); |
832 spin_lock_bh(&master->internal_lock); |
847 ec_master_queue_datagram(master, &master->fsm_datagram); |
833 ec_master_queue_datagram(master, &master->fsm_datagram); |
848 ecrt_master_send(master); |
834 ecrt_master_send(master); |
849 spin_unlock_bh(&master->internal_lock); |
835 spin_unlock_bh(&master->internal_lock); |
850 |
836 |
851 cycles_end = get_cycles(); |
|
852 master->idle_cycle_times[master->idle_cycle_time_pos] |
|
853 = (u32) (cycles_end - cycles_start) * 1000 / cpu_khz; |
|
854 master->idle_cycle_time_pos++; |
|
855 master->idle_cycle_time_pos %= HZ; |
|
856 |
|
857 schedule: |
837 schedule: |
858 if (ec_fsm_master_idle(&master->fsm)) { |
838 if (ec_fsm_master_idle(&master->fsm)) { |
859 set_current_state(TASK_INTERRUPTIBLE); |
839 set_current_state(TASK_INTERRUPTIBLE); |
860 schedule_timeout(1); |
840 schedule_timeout(1); |
861 } |
841 } |
874 |
854 |
875 /** Master kernel thread function for IDLE phase. |
855 /** Master kernel thread function for IDLE phase. |
876 */ |
856 */ |
877 static int ec_master_operation_thread(ec_master_t *master) |
857 static int ec_master_operation_thread(ec_master_t *master) |
878 { |
858 { |
879 cycles_t cycles_start, cycles_end; |
|
880 |
|
881 daemonize("EtherCAT-OP"); |
859 daemonize("EtherCAT-OP"); |
882 allow_signal(SIGTERM); |
860 allow_signal(SIGTERM); |
883 |
861 |
884 while (!signal_pending(current)) { |
862 while (!signal_pending(current)) { |
885 ec_datagram_output_stats(&master->fsm_datagram); |
863 ec_datagram_output_stats(&master->fsm_datagram); |
886 if (master->injection_seq_rt != master->injection_seq_fsm || |
864 if (master->injection_seq_rt != master->injection_seq_fsm || |
887 master->fsm_datagram.state == EC_DATAGRAM_SENT || |
865 master->fsm_datagram.state == EC_DATAGRAM_SENT || |
888 master->fsm_datagram.state == EC_DATAGRAM_QUEUED) |
866 master->fsm_datagram.state == EC_DATAGRAM_QUEUED) |
889 goto schedule; |
867 goto schedule; |
890 |
868 |
891 cycles_start = get_cycles(); |
|
892 |
|
893 // output statistics |
869 // output statistics |
894 ec_master_output_stats(master); |
870 ec_master_output_stats(master); |
895 |
871 |
896 // execute master state machine |
872 // execute master state machine |
897 ec_fsm_master_exec(&master->fsm); |
873 ec_fsm_master_exec(&master->fsm); |
898 |
874 |
899 // inject datagram |
875 // inject datagram |
900 master->injection_seq_fsm++; |
876 master->injection_seq_fsm++; |
901 |
|
902 cycles_end = get_cycles(); |
|
903 master->idle_cycle_times[master->idle_cycle_time_pos] |
|
904 = (u32) (cycles_end - cycles_start) * 1000 / cpu_khz; |
|
905 master->idle_cycle_time_pos++; |
|
906 master->idle_cycle_time_pos %= HZ; |
|
907 |
877 |
908 schedule: |
878 schedule: |
909 if (ec_fsm_master_idle(&master->fsm)) { |
879 if (ec_fsm_master_idle(&master->fsm)) { |
910 set_current_state(TASK_INTERRUPTIBLE); |
880 set_current_state(TASK_INTERRUPTIBLE); |
911 schedule_timeout(1); |
881 schedule_timeout(1); |
970 void ec_master_eoe_run(unsigned long data /**< master pointer */) |
940 void ec_master_eoe_run(unsigned long data /**< master pointer */) |
971 { |
941 { |
972 ec_master_t *master = (ec_master_t *) data; |
942 ec_master_t *master = (ec_master_t *) data; |
973 ec_eoe_t *eoe; |
943 ec_eoe_t *eoe; |
974 unsigned int none_open = 1; |
944 unsigned int none_open = 1; |
975 cycles_t cycles_start, cycles_end; |
|
976 unsigned long restart_jiffies; |
945 unsigned long restart_jiffies; |
977 |
946 |
978 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
947 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
979 if (ec_eoe_is_open(eoe)) { |
948 if (ec_eoe_is_open(eoe)) { |
980 none_open = 0; |
949 none_open = 0; |
983 } |
952 } |
984 if (none_open) |
953 if (none_open) |
985 goto queue_timer; |
954 goto queue_timer; |
986 |
955 |
987 // receive datagrams |
956 // receive datagrams |
988 if (master->request_cb(master->cb_data)) goto queue_timer; |
957 if (master->request_cb(master->cb_data)) |
989 cycles_start = get_cycles(); |
958 goto queue_timer; |
|
959 |
990 ecrt_master_receive(master); |
960 ecrt_master_receive(master); |
991 master->release_cb(master->cb_data); |
961 master->release_cb(master->cb_data); |
992 |
962 |
993 // actual EoE processing |
963 // actual EoE processing |
994 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
964 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
1002 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
972 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
1003 ec_eoe_queue(eoe); |
973 ec_eoe_queue(eoe); |
1004 } |
974 } |
1005 ecrt_master_send(master); |
975 ecrt_master_send(master); |
1006 master->release_cb(master->cb_data); |
976 master->release_cb(master->cb_data); |
1007 cycles_end = get_cycles(); |
|
1008 |
|
1009 master->eoe_cycle_times[master->eoe_cycle_time_pos] |
|
1010 = (u32) (cycles_end - cycles_start) * 1000 / cpu_khz; |
|
1011 master->eoe_cycle_time_pos++; |
|
1012 master->eoe_cycle_time_pos %= HZ; |
|
1013 |
977 |
1014 queue_timer: |
978 queue_timer: |
1015 restart_jiffies = HZ / EC_EOE_FREQUENCY; |
979 restart_jiffies = HZ / EC_EOE_FREQUENCY; |
1016 if (!restart_jiffies) restart_jiffies = 1; |
980 if (!restart_jiffies) restart_jiffies = 1; |
1017 master->eoe_timer.expires = jiffies + restart_jiffies; |
981 master->eoe_timer.expires = jiffies + restart_jiffies; |