etherlabmaster: comparison master/master.c

equal deleted inserted replaced

-:ac35f4d38a31
+:55854f070c4a
 int ret;
 master->index = index;
 master->reserved = 0;
-sema_init(&master->master_sem, 1);
+ec_mutex_init(&master->master_mutex);
 master->main_mac = main_mac;
 master->backup_mac = backup_mac;
-sema_init(&master->device_sem, 1);
+ec_mutex_init(&master->device_mutex);
 master->phase = EC_ORPHANED;
 master->active = 0;
 master->config_changed = 0;
 master->injection_seq_fsm = 0;
 master->app_start_time = 0ULL;
 master->has_app_time = 0;
 master->scan_busy = 0;
 master->allow_scan = 1;
-sema_init(&master->scan_sem, 1);
+ec_mutex_init(&master->scan_mutex);
 init_waitqueue_head(&master->scan_queue);
 master->config_busy = 0;
 master->allow_config = 1;
-sema_init(&master->config_sem, 1);
+ec_mutex_init(&master->config_mutex);
 init_waitqueue_head(&master->config_queue);
 INIT_LIST_HEAD(&master->datagram_queue);
 master->datagram_index = 0;
-sema_init(&master->fsm_queue_sem, 1);
+ec_mutex_init(&master->fsm_queue_mutex);
 INIT_LIST_HEAD(&master->fsm_datagram_queue);
 // send interval in IDLE phase
 ec_master_set_send_interval(master, 1000000 / HZ);
 #ifdef EC_EOE
 master->eoe_thread = NULL;
 INIT_LIST_HEAD(&master->eoe_handlers);
 #endif
-sema_init(&master->io_sem, 1);
+ec_mutex_init(&master->io_mutex);
 master->fsm_queue_lock_cb = NULL;
 master->fsm_queue_unlock_cb = NULL;
 master->fsm_queue_locking_data = NULL;
 master->app_fsm_queue_lock_cb = NULL;
 master->app_fsm_queue_unlock_cb = NULL;
 */
 void ec_master_clear_config(
 ec_master_t *master /**< EtherCAT master. */
 )
 {
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 ec_master_clear_domains(master);
 ec_master_clear_slave_configs(master);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 /*****************************************************************************/
 /** Starts the master thread.
 master->phase = EC_ORPHANED;
 ec_master_thread_stop(master);
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 ec_master_clear_slaves(master);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 /*****************************************************************************/
 /** Transition function from IDLE to OPERATION phase.
 ec_eoe_t *eoe;
 #endif
 EC_MASTER_DBG(master, 1, "IDLE -> OPERATION.\n");
-down(&master->config_sem);
+ec_mutex_lock(&master->config_mutex);
 master->allow_config = 0; // temporarily disable slave configuration
 if (master->config_busy) {
-up(&master->config_sem);
+ec_mutex_unlock(&master->config_mutex);
 // wait for slave configuration to complete
 ret = wait_event_interruptible(master->config_queue,
 !master->config_busy);
 if (ret) {
 }
 EC_MASTER_DBG(master, 1, "Waiting for pending slave"
 " configuration returned.\n");
 } else {
-up(&master->config_sem);
+ec_mutex_unlock(&master->config_mutex);
 }
-down(&master->scan_sem);
+ec_mutex_lock(&master->scan_mutex);
 master->allow_scan = 0; // 'lock' the slave list
 if (!master->scan_busy) {
-up(&master->scan_sem);
+ec_mutex_unlock(&master->scan_mutex);
 } else {
-up(&master->scan_sem);
+ec_mutex_unlock(&master->scan_mutex);
 // wait for slave scan to complete
 ret = wait_event_interruptible(master->scan_queue, !master->scan_busy);
 if (ret) {
 EC_MASTER_INFO(master, "Waiting for slave scan"
 ec_datagram_t *datagram, *n;
 size_t queue_size = 0;
 if (master->fsm_queue_lock_cb)
 master->fsm_queue_lock_cb(master->fsm_queue_locking_data);
-down(&master->fsm_queue_sem);
+if (ec_mutex_trylock(&master->fsm_queue_mutex) == 0)
+return;
 if (list_empty(&master->fsm_datagram_queue)) {
-up(&master->fsm_queue_sem);
+ec_mutex_unlock(&master->fsm_queue_mutex);
 if (master->fsm_queue_unlock_cb)
 master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
 return;
 }
 list_for_each_entry(datagram, &master->datagram_queue, queue) {
 }
 #endif
 }
 }
 }
-up(&master->fsm_queue_sem);
+ec_mutex_unlock(&master->fsm_queue_mutex);
 if (master->fsm_queue_unlock_cb)
 master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
 }
 /*****************************************************************************/
 {
 ec_datagram_t *queued_datagram;
 if (master->fsm_queue_lock_cb)
 master->fsm_queue_lock_cb(master->fsm_queue_locking_data);
-down(&master->fsm_queue_sem);
+ec_mutex_lock(&master->fsm_queue_mutex);
 // check, if the datagram is already queued
 list_for_each_entry(queued_datagram, &master->fsm_datagram_queue,
 queue) {
 if (queued_datagram == datagram) {
 datagram->state = EC_DATAGRAM_QUEUED;
-up(&master->fsm_queue_sem);
+ec_mutex_unlock(&master->fsm_queue_mutex);
 if (master->fsm_queue_unlock_cb)
 master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
 return;
 }
 }
 #ifdef EC_HAVE_CYCLES
 datagram->cycles_sent = get_cycles();
 #endif
 datagram->jiffies_sent = jiffies;
-up(&master->fsm_queue_sem);
+ec_mutex_unlock(&master->fsm_queue_mutex);
 if (master->fsm_queue_unlock_cb)
 master->fsm_queue_unlock_cb(master->fsm_queue_locking_data);
 }
 /*****************************************************************************/
 while (!kthread_should_stop()) {
 ec_datagram_output_stats(&master->fsm_datagram);
 // receive
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 ecrt_master_receive(master);
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 // execute master & slave state machines
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 break;
 if (ec_fsm_master_exec(&master->fsm)) {
 ec_master_queue_fsm_datagram(master, &master->fsm_datagram);
 }
 for (slave = master->slaves;
 }
 #if defined(EC_EOE)
 if (!ec_master_eoe_processing(master))
 master->fsm.idle = 0;  // pump the bus as fast as possible
 #endif
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // queue and send
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 ecrt_master_send(master);
 sent_bytes = master->main_device.tx_skb[
 master->main_device.tx_ring_index]->len;
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 if (ec_fsm_master_idle(&master->fsm)) {
 #ifdef EC_USE_HRTIMER
 ec_master_nanosleep(master->send_interval * 1000);
 #else
 // output statistics
 ec_master_output_stats(master);
 // execute master & slave state machines
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 break;
 if (ec_fsm_master_exec(&master->fsm))
 ec_master_queue_fsm_datagram(master, &master->fsm_datagram);
 for (slave = master->slaves;
 slave < master->slaves + master->slave_count;
 ec_fsm_slave_exec(&slave->fsm); // may queue datagram in external queue
 }
 #if defined(EC_EOE)
 ec_master_eoe_processing(master);
 #endif
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 #ifdef EC_USE_HRTIMER
 // the op thread should not work faster than the sending RT thread
 ec_master_nanosleep(master->send_interval * 1000);
 #else
 if (!(domain = (ec_domain_t *) kmalloc(sizeof(ec_domain_t), GFP_KERNEL))) {
 EC_MASTER_ERR(master, "Error allocating domain memory!\n");
 return ERR_PTR(-ENOMEM);
 }
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 if (list_empty(&master->domains)) {
 index = 0;
 } else {
 last_domain = list_entry(master->domains.prev, ec_domain_t, list);
 }
 ec_domain_init(domain, master, index);
 list_add_tail(&domain->list, &master->domains);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_DBG(master, 1, "Created domain %u.\n", domain->index);
 return domain;
 }
 if (master->active) {
 EC_MASTER_WARN(master, "%s: Master already active!\n", __func__);
 return 0;
 }
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 // finish all domains
 domain_offset = 0;
 list_for_each_entry(domain, &master->domains, list) {
 ret = ec_domain_finish(domain, domain_offset);
 if (ret < 0) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Failed to finish domain 0x%p!\n", domain);
 return ret;
 }
 domain_offset += domain->data_size;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // restart EoE process and master thread with new locking
 ec_master_thread_stop(master);
 }
 ec_slave_config_init(sc, master,
 alias, position, vendor_id, product_code);
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 // try to find the addressed slave
 ec_slave_config_attach(sc);
 ec_slave_config_load_default_sync_config(sc);
 list_add_tail(&sc->list, &master->configs);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 return sc;
 }
 int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,
 ec_slave_info_t *slave_info)
 {
 const ec_slave_t *slave;
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 return -EINTR;
 }
 slave = ec_master_find_slave_const(master, 0, slave_position);
 strncpy(slave_info->name, slave->sii.name, EC_MAX_STRING_LENGTH);
 } else {
 slave_info->name[0] = 0;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return 0;
 }
 /*****************************************************************************/
 memcpy(request.req.data, data, data_size);
 request.req.data_size = data_size;
 ec_soe_request_write(&request.req);
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(request.slave = ec_master_find_slave(
 master, 0, slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 slave_position);
 ec_soe_request_clear(&request.req);
 return -EINVAL;
 }
 EC_SLAVE_DBG(request.slave, 1, "Scheduling SoE write request.\n");
 // schedule SoE write request.
 list_add_tail(&request.list, &request.slave->soe_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
 if (wait_event_interruptible(request.slave->soe_queue,
 request.req.state != EC_INT_REQUEST_QUEUED)) {
 // interrupted by signal
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 if (request.req.state == EC_INT_REQUEST_QUEUED) {
 // abort request
 list_del(&request.list);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ec_soe_request_clear(&request.req);
 return -EINTR;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 // wait until master FSM has finished processing
 wait_event(request.slave->soe_queue,
 request.req.state != EC_INT_REQUEST_BUSY);
 ec_soe_request_init(&request.req);
 ec_soe_request_set_drive_no(&request.req, drive_no);
 ec_soe_request_set_idn(&request.req, idn);
 ec_soe_request_read(&request.req);
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(request.slave = ec_master_find_slave(master, 0, slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ec_soe_request_clear(&request.req);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n", slave_position);
 return -EINVAL;
 }
 // schedule request.
 list_add_tail(&request.list, &request.slave->soe_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_DBG(request.slave, 1, "Scheduled SoE read request.\n");
 // wait for processing through FSM
 if (wait_event_interruptible(request.slave->soe_queue,
 request.req.state != EC_INT_REQUEST_QUEUED)) {
 // interrupted by signal
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 if (request.req.state == EC_INT_REQUEST_QUEUED) {
 list_del(&request.list);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ec_soe_request_clear(&request.req);
 return -EINTR;
 }
 // request already processing: interrupt not possible.
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 // wait until master FSM has finished processing
 wait_event(request.slave->soe_queue,
 request.req.state != EC_INT_REQUEST_BUSY);

changeset 2028	55854f070c4a
parent 2024	96e2ae6cce95
child 2030	2bd8ad8bf41f