master/master.c
branchstable-1.5
changeset 2455 c6b1c8fd20f4
parent 2453 d461b1f07296
child 2456 a9bbc44584e0
equal deleted inserted replaced
2454:5cf6bb14a579 2455:c6b1c8fd20f4
   563 
   563 
   564     kthread_stop(master->thread);
   564     kthread_stop(master->thread);
   565     master->thread = NULL;
   565     master->thread = NULL;
   566     EC_MASTER_INFO(master, "Master thread exited.\n");
   566     EC_MASTER_INFO(master, "Master thread exited.\n");
   567 
   567 
   568     if (master->fsm_datagram.state != EC_DATAGRAM_SENT)
   568     if (master->fsm_datagram.state != EC_DATAGRAM_SENT) {
   569         return;
   569         return;
       
   570     }
   570 
   571 
   571     // wait for FSM datagram
   572     // wait for FSM datagram
   572     sleep_jiffies = max(HZ / 100, 1); // 10 ms, at least 1 jiffy
   573     sleep_jiffies = max(HZ / 100, 1); // 10 ms, at least 1 jiffy
   573     schedule_timeout(sleep_jiffies);
   574     schedule_timeout(sleep_jiffies);
   574 }
   575 }
  1384         down(&master->io_sem);
  1385         down(&master->io_sem);
  1385         ecrt_master_receive(master);
  1386         ecrt_master_receive(master);
  1386         up(&master->io_sem);
  1387         up(&master->io_sem);
  1387 
  1388 
  1388         fsm_exec = 0;
  1389         fsm_exec = 0;
       
  1390 
  1389         // execute master & slave state machines
  1391         // execute master & slave state machines
  1390         if (down_interruptible(&master->master_sem))
  1392         if (down_interruptible(&master->master_sem)) {
  1391             break;
  1393             break;
       
  1394         }
       
  1395 
  1392         fsm_exec = ec_fsm_master_exec(&master->fsm);
  1396         fsm_exec = ec_fsm_master_exec(&master->fsm);
       
  1397 
  1393         for (slave = master->slaves;
  1398         for (slave = master->slaves;
  1394                 slave < master->slaves + master->slave_count;
  1399                 slave < master->slaves + master->slave_count;
  1395                 slave++) {
  1400                 slave++) {
  1396             ec_fsm_slave_exec(&slave->fsm);
  1401             ec_fsm_slave_exec(&slave->fsm);
  1397         }
  1402         }
       
  1403 
  1398         up(&master->master_sem);
  1404         up(&master->master_sem);
  1399 
  1405 
  1400         // queue and send
  1406         // queue and send
  1401         down(&master->io_sem);
  1407         down(&master->io_sem);
  1402         if (fsm_exec) {
  1408         if (fsm_exec) {
  1450         if (master->injection_seq_rt == master->injection_seq_fsm) {
  1456         if (master->injection_seq_rt == master->injection_seq_fsm) {
  1451             // output statistics
  1457             // output statistics
  1452             ec_master_output_stats(master);
  1458             ec_master_output_stats(master);
  1453 
  1459 
  1454             fsm_exec = 0;
  1460             fsm_exec = 0;
       
  1461 
  1455             // execute master & slave state machines
  1462             // execute master & slave state machines
  1456             if (down_interruptible(&master->master_sem))
  1463             if (down_interruptible(&master->master_sem)) {
  1457                 break;
  1464                 break;
       
  1465             }
       
  1466 
  1458             fsm_exec += ec_fsm_master_exec(&master->fsm);
  1467             fsm_exec += ec_fsm_master_exec(&master->fsm);
       
  1468 
  1459             for (slave = master->slaves;
  1469             for (slave = master->slaves;
  1460                     slave < master->slaves + master->slave_count;
  1470                     slave < master->slaves + master->slave_count;
  1461                     slave++) {
  1471                     slave++) {
  1462                 ec_fsm_slave_exec(&slave->fsm);
  1472                 ec_fsm_slave_exec(&slave->fsm);
  1463             }
  1473             }
       
  1474 
  1464             up(&master->master_sem);
  1475             up(&master->master_sem);
  1465 
  1476 
  1466             // inject datagrams (let the rt thread queue them, see
  1477             // inject datagrams (let the rt thread queue them, see
  1467             // ecrt_master_send)
  1478             // ecrt_master_send)
  1468             if (fsm_exec)
  1479             if (fsm_exec) {
  1469                 master->injection_seq_fsm++;
  1480                 master->injection_seq_fsm++;
       
  1481             }
  1470         }
  1482         }
  1471 
  1483 
  1472 #ifdef EC_USE_HRTIMER
  1484 #ifdef EC_USE_HRTIMER
  1473         // the op thread should not work faster than the sending RT thread
  1485         // the op thread should not work faster than the sending RT thread
  1474         ec_master_nanosleep(master->send_interval * 1000);
  1486         ec_master_nanosleep(master->send_interval * 1000);
  2259     if (eoe_was_running) {
  2271     if (eoe_was_running) {
  2260         ec_master_eoe_start(master);
  2272         ec_master_eoe_start(master);
  2261     }
  2273     }
  2262 #endif
  2274 #endif
  2263     if (ec_master_thread_start(master, ec_master_idle_thread,
  2275     if (ec_master_thread_start(master, ec_master_idle_thread,
  2264                 "EtherCAT-IDLE"))
  2276                 "EtherCAT-IDLE")) {
  2265         EC_MASTER_WARN(master, "Failed to restart master thread!\n");
  2277         EC_MASTER_WARN(master, "Failed to restart master thread!\n");
       
  2278     }
  2266 
  2279 
  2267     /* Disallow scanning to get into the same state like after a master
  2280     /* Disallow scanning to get into the same state like after a master
  2268      * request (after ec_master_enter_operation_phase() is called). */
  2281      * request (after ec_master_enter_operation_phase() is called). */
  2269     master->allow_scan = 0;
  2282     master->allow_scan = 0;
  2270 
  2283