etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:5461fce4a2ea
+:ed1a733efbc5
 init_waitqueue_head(&master->config_queue);
 INIT_LIST_HEAD(&master->datagram_queue);
 master->datagram_index = 0;
+INIT_LIST_HEAD(&master->ext_datagram_queue);
+init_MUTEX(&master->ext_queue_sem);
 INIT_LIST_HEAD(&master->domains);
 master->debug_level = debug_level;
 master->stats.timeouts = 0;
 master->stats.corrupted = 0;
 master->eoe_thread = NULL;
 INIT_LIST_HEAD(&master->eoe_handlers);
 #endif
 init_MUTEX(&master->io_sem);
-master->request_cb = NULL;
+master->send_cb = NULL;
-master->release_cb = NULL;
+master->receive_cb = NULL;
-master->cb_data = NULL;
+master->app_send_cb = NULL;
+master->app_receive_cb = NULL;
 INIT_LIST_HEAD(&master->sii_requests);
 init_waitqueue_head(&master->sii_queue);
 INIT_LIST_HEAD(&master->slave_sdo_requests);
 }
 }
 /*****************************************************************************/
-/** Internal locking callback.
+/** Internal sending callback.
 */
-int ec_master_request_cb(void *data /**< callback data */)
+void ec_master_internal_send_cb(
-{
+ec_master_t *master /**< EtherCAT master. */
-ec_master_t *master = (ec_master_t *) data;
+)
+{
 down(&master->io_sem);
-return 0;
+ecrt_master_send_ext(master);
-}
+up(&master->io_sem);
+}
-/*****************************************************************************/
+/*****************************************************************************/
-/** Internal unlocking callback.
-*/
+/** Internal receiving callback.
-void ec_master_release_cb(void *data /**< callback data */)
+*/
-{
+void ec_master_internal_receive_cb(
-ec_master_t *master = (ec_master_t *) data;
+ec_master_t *master /**< EtherCAT master. */
+)
+{
+down(&master->io_sem);
+ecrt_master_receive(master);
 up(&master->io_sem);
 }
 /*****************************************************************************/
 int ret;
 if (master->debug_level)
 EC_DBG("ORPHANED -> IDLE.\n");
-master->request_cb = ec_master_request_cb;
+master->send_cb = ec_master_internal_send_cb;
-master->release_cb = ec_master_release_cb;
+master->receive_cb = ec_master_internal_receive_cb;
-master->cb_data = master;
 master->phase = EC_IDLE;
 ret = ec_master_thread_start(master, ec_master_idle_thread,
 "EtherCAT-IDLE");
 if (ret)
 ec_slave_request_state(eoe->slave, EC_SLAVE_STATE_OP);
 }
 #endif
 master->phase = EC_OPERATION;
-master->ext_request_cb = NULL;
+master->app_send_cb = NULL;
-master->ext_release_cb = NULL;
+master->app_receive_cb = NULL;
-master->ext_cb_data = NULL;
 return ret;
 out_allow:
 master->allow_scan = 1;
 master->allow_config = 1;
 #ifdef EC_EOE
 ec_master_eoe_stop(master);
 #endif
 ec_master_thread_stop(master);
-master->request_cb = ec_master_request_cb;
+master->send_cb = ec_master_internal_send_cb;
-master->release_cb = ec_master_release_cb;
+master->receive_cb = ec_master_internal_receive_cb;
-master->cb_data = master;
 down(&master->master_sem);
 ec_master_clear_domains(master);
 ec_master_clear_slave_configs(master);
 up(&master->master_sem);
 /*****************************************************************************/
 /** Places a datagram in the datagram queue.
 */
-void ec_master_queue_datagram(ec_master_t *master, /**< EtherCAT master */
+void ec_master_queue_datagram(
-ec_datagram_t *datagram /**< datagram */
+ec_master_t *master, /**< EtherCAT master */
-)
+ec_datagram_t *datagram /**< datagram */
+)
 {
 ec_datagram_t *queued_datagram;
 // check, if the datagram is already queued
 list_for_each_entry(queued_datagram, &master->datagram_queue, queue) {
 }
 }
 list_add_tail(&datagram->queue, &master->datagram_queue);
 datagram->state = EC_DATAGRAM_QUEUED;
+}
+/*****************************************************************************/
+/** Places a datagram in the non-application datagram queue.
+*/
+void ec_master_queue_datagram_ext(
+ec_master_t *master, /**< EtherCAT master */
+ec_datagram_t *datagram /**< datagram */
+)
+{
+down(&master->ext_queue_sem);
+list_add_tail(&datagram->queue, &master->ext_datagram_queue);
+up(&master->ext_queue_sem);
 }
 /*****************************************************************************/
 /** Sends the datagrams in the queue.
 }
 if (list_empty(&master->eoe_handlers))
 return;
-if (!master->request_cb || !master->release_cb) {
+if (!master->send_cb || !master->receive_cb) {
-EC_WARN("No EoE processing because of missing locking callbacks!\n");
+EC_WARN("No EoE processing because of missing callbacks!\n");
 return;
 }
 EC_INFO("Starting EoE thread.\n");
 master->eoe_thread = kthread_run(ec_master_eoe_thread, master,
 }
 if (none_open)
 goto schedule;
 // receive datagrams
-if (master->request_cb(master->cb_data))
+master->receive_cb(master);
-goto schedule;
-ecrt_master_receive(master);
-master->release_cb(master->cb_data);
 // actual EoE processing
 sth_to_send = 0;
 list_for_each_entry(eoe, &master->eoe_handlers, list) {
 ec_eoe_run(eoe);
 all_idle = 0;
 }
 }
 if (sth_to_send) {
-// send datagrams
-if (master->request_cb(master->cb_data)) {
-goto schedule;
-}
 list_for_each_entry(eoe, &master->eoe_handlers, list) {
 ec_eoe_queue(eoe);
 }
-ecrt_master_send(master);
+// (try to) send datagrams
-master->release_cb(master->cb_data);
+down(&master->ext_queue_sem);
+master->send_cb(master);
+up(&master->ext_queue_sem);
 }
 schedule:
 if (all_idle) {
 set_current_state(TASK_INTERRUPTIBLE);
 if (master->debug_level)
 EC_DBG("FSM datagram is %x.\n", (unsigned int) &master->fsm_datagram);
 master->injection_seq_fsm = 0;
 master->injection_seq_rt = 0;
-master->request_cb = master->ext_request_cb;
-master->release_cb = master->ext_release_cb;
+master->send_cb = master->app_send_cb;
-master->cb_data = master->ext_cb_data;
+master->receive_cb = master->app_receive_cb;
 ret = ec_master_thread_start(master, ec_master_operation_thread,
 "EtherCAT-OP");
 if (ret < 0) {
 EC_ERR("Failed to start master thread!\n");
 master->frames_timed_out = frames_timed_out;
 }
 /*****************************************************************************/
+void ecrt_master_send_ext(ec_master_t *master)
+{
+ec_datagram_t *datagram, *next;
+list_for_each_entry_safe(datagram, next, &master->ext_datagram_queue,
+queue) {
+list_del(&datagram->queue);
+ec_master_queue_datagram(master, datagram);
+}
+ecrt_master_send(master);
+}
+/*****************************************************************************/
 /** Same as ecrt_master_slave_config(), but with ERR_PTR() return value.
 */
 ec_slave_config_t *ecrt_master_slave_config_err(ec_master_t *master,
 uint16_t alias, uint16_t position, uint32_t vendor_id,
 uint32_t product_code)
 return IS_ERR(sc) ? NULL : sc;
 }
 /*****************************************************************************/
-void ecrt_master_callbacks(ec_master_t *master, int (*request_cb)(void *),
+void ecrt_master_callbacks(ec_master_t *master,
-void (*release_cb)(void *), void *cb_data)
+void (*send_cb)(ec_master_t *), void (*receive_cb)(ec_master_t *))
 {
 if (master->debug_level)
-EC_DBG("ecrt_master_callbacks(master = 0x%x, request_cb = 0x%x, "
+EC_DBG("ecrt_master_callbacks(master = 0x%x, send_cb = 0x%x, "
-" release_cb = 0x%x, cb_data = 0x%x)\n", (u32) master,
+" receive_cb = 0x%x)\n", (u32) master, (u32) send_cb,
-(u32) request_cb, (u32) release_cb, (u32) cb_data);
+(u32) receive_cb);
-master->ext_request_cb = request_cb;
+master->app_send_cb = send_cb;
-master->ext_release_cb = release_cb;
+master->app_receive_cb = receive_cb;
-master->ext_cb_data = cb_data;
 }
 /*****************************************************************************/
 void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
 /** \cond */
 EXPORT_SYMBOL(ecrt_master_create_domain);
 EXPORT_SYMBOL(ecrt_master_activate);
 EXPORT_SYMBOL(ecrt_master_send);
+EXPORT_SYMBOL(ecrt_master_send_ext);
 EXPORT_SYMBOL(ecrt_master_receive);
 EXPORT_SYMBOL(ecrt_master_callbacks);
 EXPORT_SYMBOL(ecrt_master_slave_config);
 EXPORT_SYMBOL(ecrt_master_state);
 EXPORT_SYMBOL(ecrt_master_application_time);

changeset 1500	ed1a733efbc5
parent 1489	f77a1182b6f4
child 1507	68e89abadd19