etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:69056c46aa4d
+:bc2d4bf9cbe5
 master->injection_seq_fsm = 0;
 master->injection_seq_rt = 0;
 master->slaves = NULL;
 master->slave_count = 0;
 INIT_LIST_HEAD(&master->configs);
 INIT_LIST_HEAD(&master->domains);
 master->app_time = 0ULL;
 master->app_start_time = 0ULL;
 init_waitqueue_head(&master->scan_queue);
 master->config_busy = 0;
 sema_init(&master->config_sem, 1);
 init_waitqueue_head(&master->config_queue);
 INIT_LIST_HEAD(&master->datagram_queue);
 master->datagram_index = 0;
 INIT_LIST_HEAD(&master->ext_datagram_queue);
 sema_init(&master->ext_queue_sem, 1);
 INIT_LIST_HEAD(&master->external_datagram_queue);
 // send interval in IDLE phase
 ec_master_set_send_interval(master, 1000000 / HZ);
 master->debug_level = debug_level;
 master->stats.timeouts = 0;
 // init character device
 ret = ec_cdev_init(&master->cdev, master, device_number);
 if (ret)
 goto out_clear_sync_mon;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
 master->class_device = device_create(class, NULL,
 MKDEV(MAJOR(device_number), master->index), NULL,
 "EtherCAT%u", master->index);
 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)
 #else
 class_device_unregister(master->class_device);
 #endif
 ec_cdev_clear(&master->cdev);
 #ifdef EC_EOE
 ec_master_clear_eoe_handlers(master);
 #endif
 ec_master_clear_domains(master);
 ec_master_clear_slave_configs(master);
 EC_MASTER_ERR(master, "Failed to start master thread (error %i)!\n",
 err);
 master->thread = NULL;
 return err;
 }
 return 0;
 }
 /*****************************************************************************/
 void ec_master_thread_stop(
 ec_master_t *master /**< EtherCAT master */
 )
 {
 unsigned long sleep_jiffies;
 if (!master->thread) {
 EC_MASTER_WARN(master, "%s(): Already finished!\n", __func__);
 return;
 }
 master->thread = NULL;
 EC_MASTER_INFO(master, "Master thread exited.\n");
 if (master->fsm_datagram.state != EC_DATAGRAM_SENT)
 return;
 // wait for FSM datagram
 sleep_jiffies = max(HZ / 100, 1); // 10 ms, at least 1 jiffy
 schedule_timeout(sleep_jiffies);
 }
 void ec_master_leave_idle_phase(ec_master_t *master /**< EtherCAT master */)
 {
 EC_MASTER_DBG(master, 1, "IDLE -> ORPHANED.\n");
 master->phase = EC_ORPHANED;
 #ifdef EC_EOE
 ec_master_eoe_stop(master);
 #endif
 ec_master_thread_stop(master);
 if (ret) {
 EC_MASTER_INFO(master, "Waiting for slave scan"
 " interrupted by signal.\n");
 goto out_allow;
 }
 EC_MASTER_DBG(master, 1, "Waiting for pending"
 " slave scan returned.\n");
 }
 // set states for all slaves
 master->phase = EC_OPERATION;
 master->app_send_cb = NULL;
 master->app_receive_cb = NULL;
 master->app_cb_data = NULL;
 return ret;
 out_allow:
 master->allow_scan = 1;
 out_return:
 return ret;
 }
 /*****************************************************************************/
 /** Processes a received frame.
 *
 * This function is called by the network driver for every received frame.
 *
 * \return 0 in case of success, else < 0
 */
 void ec_master_receive_datagrams(ec_master_t *master, /**< EtherCAT master */
 const uint8_t *frame_data, /**< frame data */
 size_t size /**< size of the received data */
 #ifdef EC_USE_HRTIMER
 size_t sent_bytes;
 #endif
 // send interval in IDLE phase
 ec_master_set_send_interval(master, 1000000 / HZ);
 EC_MASTER_DBG(master, 1, "Idle thread running with send interval = %u us,"
 " max data size=%zu\n", master->send_interval,
 master->max_queue_size);
 #else
 schedule();
 #endif
 }
 }
 EC_MASTER_DBG(master, 1, "Master IDLE thread exiting...\n");
 return 0;
 }
 else {
 schedule();
 }
 #endif
 }
 EC_MASTER_DBG(master, 1, "Master OP thread exiting...\n");
 return 0;
 }
 /*****************************************************************************/
 schedule_timeout(1);
 } else {
 schedule();
 }
 }
 EC_MASTER_DBG(master, 1, "EoE thread exiting...\n");
 return 0;
 }
 #endif
 )
 {
 ec_slave_config_t *sc;
 list_for_each_entry(sc, &master->configs, list) {
 ec_slave_config_detach(sc);
 }
 }
 /*****************************************************************************/
 break;
 }
 }
 master->dc_ref_clock = ref;
 // This call always succeeds, because the datagram has been pre-allocated.
 ec_datagram_frmw(&master->sync_datagram,
 ref ? ref->station_address : 0xffff, 0x0910, 4);
 }
 EC_MASTER_ERR(master, "Failed to finish domain 0x%p!\n", domain);
 return ret;
 }
 domain_offset += domain->data_size;
 }
 up(&master->master_sem);
 // restart EoE process and master thread with new locking
 ec_master_thread_stop(master);
 master->injection_seq_rt = 0;
 master->send_cb = master->app_send_cb;
 master->receive_cb = master->app_receive_cb;
 master->cb_data = master->app_cb_data;
 #ifdef EC_EOE
 if (eoe_was_running) {
 ec_master_eoe_start(master);
 }
 #endif
 ec_master_thread_stop(master);
 #ifdef EC_EOE
 eoe_was_running = master->eoe_thread != NULL;
 ec_master_eoe_stop(master);
 #endif
 master->send_cb = ec_master_internal_send_cb;
 master->receive_cb = ec_master_internal_receive_cb;
 master->cb_data = master;
 ec_master_clear_config(master);
 for (slave = master->slaves;
 slave < master->slaves + master->slave_count;
 slave++) {

branch	stable-1.5
changeset 2421	bc2d4bf9cbe5
parent 2419	fdb85a806585
child 2433	3bdd7a747fae