328 } |
328 } |
329 |
329 |
330 /*****************************************************************************/ |
330 /*****************************************************************************/ |
331 |
331 |
332 /** |
332 /** |
|
333 Internal locking callback. |
|
334 */ |
|
335 |
|
336 int ec_master_request_cb(void *master /**< callback data */) |
|
337 { |
|
338 spin_lock(&((ec_master_t *) master)->internal_lock); |
|
339 return 0; |
|
340 } |
|
341 |
|
342 /*****************************************************************************/ |
|
343 |
|
344 /** |
|
345 Internal unlocking callback. |
|
346 */ |
|
347 |
|
348 void ec_master_release_cb(void *master /**< callback data */) |
|
349 { |
|
350 spin_unlock(&((ec_master_t *) master)->internal_lock); |
|
351 } |
|
352 |
|
353 /*****************************************************************************/ |
|
354 |
|
355 /** |
333 */ |
356 */ |
334 |
357 |
335 int ec_master_enter_idle_mode(ec_master_t *master /**< EtherCAT master */) |
358 int ec_master_enter_idle_mode(ec_master_t *master /**< EtherCAT master */) |
336 { |
359 { |
|
360 master->request_cb = ec_master_request_cb; |
|
361 master->release_cb = ec_master_release_cb; |
|
362 master->cb_data = master; |
|
363 |
337 master->mode = EC_MASTER_MODE_IDLE; |
364 master->mode = EC_MASTER_MODE_IDLE; |
338 queue_delayed_work(master->workqueue, &master->idle_work, 1); |
365 queue_delayed_work(master->workqueue, &master->idle_work, 1); |
339 return 0; |
366 return 0; |
340 } |
367 } |
341 |
368 |
453 && fsm->slave_state != ec_fsm_slave_state_error); |
480 && fsm->slave_state != ec_fsm_slave_state_error); |
454 } |
481 } |
455 |
482 |
456 ec_master_destroy_domains(master); |
483 ec_master_destroy_domains(master); |
457 |
484 |
458 master->request_cb = NULL; |
485 master->request_cb = ec_master_request_cb; |
459 master->release_cb = NULL; |
486 master->release_cb = ec_master_release_cb; |
460 master->cb_data = NULL; |
487 master->cb_data = master; |
461 |
488 |
462 master->mode = EC_MASTER_MODE_IDLE; |
489 master->mode = EC_MASTER_MODE_IDLE; |
463 queue_delayed_work(master->workqueue, &master->idle_work, 1); |
490 queue_delayed_work(master->workqueue, &master->idle_work, 1); |
464 } |
491 } |
465 |
492 |
737 void ec_master_idle_run(void *data /**< master pointer */) |
764 void ec_master_idle_run(void *data /**< master pointer */) |
738 { |
765 { |
739 ec_master_t *master = (ec_master_t *) data; |
766 ec_master_t *master = (ec_master_t *) data; |
740 cycles_t cycles_start, cycles_end; |
767 cycles_t cycles_start, cycles_end; |
741 |
768 |
742 // aquire master lock |
769 cycles_start = get_cycles(); |
|
770 |
|
771 // receive |
743 spin_lock_bh(&master->internal_lock); |
772 spin_lock_bh(&master->internal_lock); |
744 |
|
745 cycles_start = get_cycles(); |
|
746 ecrt_master_receive(master); |
773 ecrt_master_receive(master); |
|
774 spin_unlock_bh(&master->internal_lock); |
747 |
775 |
748 // execute master state machine |
776 // execute master state machine |
749 ec_fsm_exec(&master->fsm); |
777 ec_fsm_exec(&master->fsm); |
750 |
778 |
|
779 // send |
|
780 spin_lock_bh(&master->internal_lock); |
751 ecrt_master_send(master); |
781 ecrt_master_send(master); |
|
782 spin_unlock_bh(&master->internal_lock); |
752 cycles_end = get_cycles(); |
783 cycles_end = get_cycles(); |
753 |
|
754 // release master lock |
|
755 spin_unlock_bh(&master->internal_lock); |
|
756 |
784 |
757 master->idle_cycle_times[master->idle_cycle_time_pos] |
785 master->idle_cycle_times[master->idle_cycle_time_pos] |
758 = (u32) (cycles_end - cycles_start) * 1000 / cpu_khz; |
786 = (u32) (cycles_end - cycles_start) * 1000 / cpu_khz; |
759 master->idle_cycle_time_pos++; |
787 master->idle_cycle_time_pos++; |
760 master->idle_cycle_time_pos %= HZ; |
788 master->idle_cycle_time_pos %= HZ; |
1109 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
1137 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
1110 if (ec_eoe_active(eoe)) active++; |
1138 if (ec_eoe_active(eoe)) active++; |
1111 } |
1139 } |
1112 if (!active) goto queue_timer; |
1140 if (!active) goto queue_timer; |
1113 |
1141 |
1114 // aquire master lock... |
1142 // receive datagrams |
1115 if (master->mode == EC_MASTER_MODE_OPERATION) { |
1143 if (master->request_cb(master->cb_data)) goto queue_timer; |
1116 // request_cb must return 0, if the lock has been aquired! |
|
1117 if (master->request_cb(master->cb_data)) |
|
1118 goto queue_timer; |
|
1119 } |
|
1120 else if (master->mode == EC_MASTER_MODE_IDLE) { |
|
1121 spin_lock(&master->internal_lock); |
|
1122 } |
|
1123 else |
|
1124 goto queue_timer; |
|
1125 |
|
1126 // actual EoE processing |
|
1127 cycles_start = get_cycles(); |
1144 cycles_start = get_cycles(); |
1128 ecrt_master_receive(master); |
1145 ecrt_master_receive(master); |
1129 |
1146 master->release_cb(master->cb_data); |
|
1147 |
|
1148 // actual EoE processing |
1130 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
1149 list_for_each_entry(eoe, &master->eoe_handlers, list) { |
1131 ec_eoe_run(eoe); |
1150 ec_eoe_run(eoe); |
1132 } |
1151 } |
1133 |
1152 |
|
1153 // send datagrams |
|
1154 if (master->request_cb(master->cb_data)) goto queue_timer; |
1134 ecrt_master_send(master); |
1155 ecrt_master_send(master); |
1135 cycles_end = get_cycles(); |
1156 cycles_end = get_cycles(); |
1136 |
1157 master->release_cb(master->cb_data); |
1137 // release lock... |
|
1138 if (master->mode == EC_MASTER_MODE_OPERATION) { |
|
1139 master->release_cb(master->cb_data); |
|
1140 } |
|
1141 else if (master->mode == EC_MASTER_MODE_IDLE) { |
|
1142 spin_unlock(&master->internal_lock); |
|
1143 } |
|
1144 |
1158 |
1145 master->eoe_cycle_times[master->eoe_cycle_time_pos] |
1159 master->eoe_cycle_times[master->eoe_cycle_time_pos] |
1146 = (u32) (cycles_end - cycles_start) * 1000 / cpu_khz; |
1160 = (u32) (cycles_end - cycles_start) * 1000 / cpu_khz; |
1147 master->eoe_cycle_time_pos++; |
1161 master->eoe_cycle_time_pos++; |
1148 master->eoe_cycle_time_pos %= HZ; |
1162 master->eoe_cycle_time_pos %= HZ; |