etherlabmaster: comparison master/cdev.c

equal deleted inserted replaced

-:ac35f4d38a31
+:55854f070c4a
 )
 {
 ec_ioctl_master_t data;
 unsigned int i;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 data.slave_count = master->slave_count;
 data.config_count = ec_master_config_count(master);
 data.domain_count = ec_master_domain_count(master);
 #ifdef EC_EOE
 data.eoe_handler_count = ec_master_eoe_handler_count(master);
 #endif
 data.phase = (uint8_t) master->phase;
 data.active = (uint8_t) master->active;
 data.scan_busy = master->scan_busy;
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
-if (down_interruptible(&master->device_sem))
+if (ec_mutex_lock_interruptible(&master->device_mutex))
 return -EINTR;
 if (master->main_device.dev) {
 memcpy(data.devices[0].address,
 master->main_device.dev->dev_addr, ETH_ALEN);
 data.devices[1].tx_byte_rates[i] =
 master->backup_device.tx_byte_rates[i];
 data.devices[1].loss_rates[i] = master->backup_device.loss_rates[i];
 }
-up(&master->device_sem);
+ec_mutex_unlock(&master->device_mutex);
 data.app_time = master->app_time;
 data.ref_clock =
 master->dc_ref_clock ? master->dc_ref_clock->ring_position : 0xffff;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n", data.position);
 return -EINVAL;
 }
 data.vendor_id = slave->sii.vendor_id;
 ec_cdev_strcpy(data.group, slave->sii.group);
 ec_cdev_strcpy(data.image, slave->sii.image);
 ec_cdev_strcpy(data.order, slave->sii.order);
 ec_cdev_strcpy(data.name, slave->sii.name);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 if (data.sync_index >= slave->sii.sync_count) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",
 data.sync_index);
 return -EINVAL;
 }
 data.default_size = sync->default_length;
 data.control_register = sync->control_register;
 data.enable = sync->enable;
 data.pdo_count = ec_pdo_list_count(&sync->pdos);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 if (data.sync_index >= slave->sii.sync_count) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",
 data.sync_index);
 return -EINVAL;
 }
 sync = &slave->sii.syncs[data.sync_index];
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sync->pdos, data.pdo_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "Sync manager %u does not contain a PDO with "
 "position %u!\n", data.sync_index, data.pdo_pos);
 return -EINVAL;
 }
 data.index = pdo->index;
 data.entry_count = ec_pdo_entry_count(pdo);
 ec_cdev_strcpy(data.name, pdo->name);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 if (data.sync_index >= slave->sii.sync_count) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",
 data.sync_index);
 return -EINVAL;
 }
 sync = &slave->sii.syncs[data.sync_index];
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sync->pdos, data.pdo_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "Sync manager %u does not contain a PDO with "
 "position %u!\n", data.sync_index, data.pdo_pos);
 return -EINVAL;
 }
 if (!(entry = ec_pdo_find_entry_by_pos_const(
 pdo, data.entry_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "PDO 0x%04X does not contain an entry with "
 "position %u!\n", data.pdo_pos, data.entry_pos);
 return -EINVAL;
 }
 data.index = entry->index;
 data.subindex = entry->subindex;
 data.bit_length = entry->bit_length;
 ec_cdev_strcpy(data.name, entry->name);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(domain = ec_master_find_domain_const(master, data.index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Domain %u does not exist!\n", data.index);
 return -EINVAL;
 }
 data.data_size = domain->data_size;
 data.logical_base_address = domain->logical_base_address;
 data.working_counter = domain->working_counter;
 data.expected_working_counter = domain->expected_working_counter;
 data.fmmu_count = ec_domain_fmmu_count(domain);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Domain %u does not exist!\n",
 data.domain_index);
 return -EINVAL;
 }
 if (!(fmmu = ec_domain_find_fmmu(domain, data.fmmu_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Domain %u has less than %u"
 " fmmu configurations.\n",
 data.domain_index, data.fmmu_index + 1);
 return -EINVAL;
 }
 data.dir = fmmu->dir;
 data.logical_address = fmmu->logical_start_address;
 data.domain_address = fmmu->domain_address;
 data.data_size = fmmu->data_size;
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Domain %u does not exist!\n",
 data.domain_index);
 return -EINVAL;
 }
 if (domain->data_size != data.data_size) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Data size mismatch %u/%zu!\n",
 data.data_size, domain->data_size);
 return -EFAULT;
 }
 if (copy_to_user((void __user *) data.target, domain->data,
 domain->data_size)) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -EFAULT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return 0;
 }
 /*****************************************************************************/
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 ec_slave_request_state(slave, data.al_state);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return 0;
 }
 /*****************************************************************************/
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 if (!(sdo = ec_slave_get_sdo_by_pos_const(
 slave, data.sdo_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "SDO %u does not exist!\n", data.sdo_position);
 return -EINVAL;
 }
 data.sdo_index = sdo->index;
 data.max_subindex = sdo->max_subindex;
 ec_cdev_strcpy(data.name, sdo->name);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 if (data.sdo_spec <= 0) {
 if (!(sdo = ec_slave_get_sdo_by_pos_const(
 slave, -data.sdo_spec))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "SDO %u does not exist!\n", -data.sdo_spec);
 return -EINVAL;
 }
 } else {
 if (!(sdo = ec_slave_get_sdo_const(
 slave, data.sdo_spec))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "SDO 0x%04X does not exist!\n",
 data.sdo_spec);
 return -EINVAL;
 }
 }
 if (!(entry = ec_sdo_get_entry_const(
 sdo, data.sdo_entry_subindex))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "SDO entry 0x%04X:%02X does not exist!\n",
 sdo->index, data.sdo_entry_subindex);
 return -EINVAL;
 }
 entry->write_access[EC_SDO_ENTRY_ACCESS_SAFEOP];
 data.write_access[EC_SDO_ENTRY_ACCESS_OP] =
 entry->write_access[EC_SDO_ENTRY_ACCESS_OP];
 ec_cdev_strcpy(data.description, entry->description);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 ec_sdo_request_init(&request->req);
 ec_sdo_request_address(&request->req,
 data.sdo_index, data.sdo_entry_subindex);
 ecrt_sdo_request_read(&request->req);
-if (down_interruptible(&master->master_sem))  {
+if (ec_mutex_lock_interruptible(&master->master_mutex))  {
 kref_put(&request->refcount,ec_master_sdo_request_release);
 return -EINTR;
 }
 if (!(request->slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 kref_put(&request->refcount,ec_master_sdo_request_release);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 // schedule request.
 kref_get(&request->refcount);
 list_add_tail(&request->list, &request->slave->slave_sdo_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
 if (wait_event_interruptible(request->slave->sdo_queue,
 ((request->req.state == EC_INT_REQUEST_SUCCESS) || (request->req.state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
 return -EFAULT;
 }
 request->req.data_size = data.data_size;
 ecrt_sdo_request_write(&request->req);
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 kref_put(&request->refcount,ec_master_sdo_request_release);
 return -EINTR;
 }
 if (!(request->slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 kref_put(&request->refcount,ec_master_sdo_request_release);
 return -EINVAL;
 }
 // schedule request.
 kref_get(&request->refcount);
 list_add_tail(&request->list, &request->slave->slave_sdo_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
 if (wait_event_interruptible(request->slave->sdo_queue,
 ((request->req.state == EC_INT_REQUEST_SUCCESS) || (request->req.state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave_const(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 if (!data.nwords
 || data.offset + data.nwords > slave->sii_nwords) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_ERR(slave, "Invalid SII read offset/size %u/%u for slave SII"
 " size %zu!\n", data.offset, data.nwords, slave->sii_nwords);
 return -EINVAL;
 }
 slave->sii_words + data.offset, data.nwords * 2))
 retval = -EFAULT;
 else
 retval = 0;
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return retval;
 }
 /*****************************************************************************/
 (void __user *) data.words, byte_size)) {
 kfree(words);
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 kfree(words);
 return -EINVAL;
 }
 request.state = EC_INT_REQUEST_QUEUED;
 // schedule SII write request.
 list_add_tail(&request.list, &master->sii_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
 if (wait_event_interruptible(master->sii_queue,
 request.state != EC_INT_REQUEST_QUEUED)) {
 // interrupted by signal
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 if (request.state == EC_INT_REQUEST_QUEUED) {
 // abort request
 list_del(&request.list);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 kfree(words);
 return -EINTR;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 // wait until master FSM has finished processing
 wait_event(master->sii_queue, request.state != EC_INT_REQUEST_BUSY);
 EC_MASTER_ERR(master, "Failed to allocate %u bytes"
 " for register data.\n", data.length);
 return -ENOMEM;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 request.state = EC_INT_REQUEST_QUEUED;
 // schedule request.
 list_add_tail(&request.list, &master->reg_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
 if (wait_event_interruptible(master->reg_queue,
 request.state != EC_INT_REQUEST_QUEUED)) {
 // interrupted by signal
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 if (request.state == EC_INT_REQUEST_QUEUED) {
 // abort request
 list_del(&request.list);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 kfree(contents);
 return -EINTR;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 // wait until master FSM has finished processing
 wait_event(master->reg_queue, request.state != EC_INT_REQUEST_BUSY);
 if (copy_from_user(contents, (void __user *) data.data, data.length)) {
 kfree(contents);
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(slave = ec_master_find_slave(
 master, 0, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 kfree(contents);
 return -EINVAL;
 }
 request.state = EC_INT_REQUEST_QUEUED;
 // schedule request.
 list_add_tail(&request.list, &master->reg_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
 if (wait_event_interruptible(master->reg_queue,
 request.state != EC_INT_REQUEST_QUEUED)) {
 // interrupted by signal
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 if (request.state == EC_INT_REQUEST_QUEUED) {
 // abort request
 list_del(&request.list);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 kfree(contents);
 return -EINTR;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 }
 // wait until master FSM has finished processing
 wait_event(master->reg_queue, request.state != EC_INT_REQUEST_BUSY);
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 data.dc_assign_activate = sc->dc_assign_activate;
 for (i = 0; i < EC_SYNC_SIGNAL_COUNT; i++) {
 data.dc_sync[i] = sc->dc_sync[i];
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 EC_MASTER_ERR(master, "Invalid sync manager index %u!\n",
 data.sync_index);
 return -EINVAL;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sc->sync_configs[data.sync_index].pdos,
 data.pdo_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Invalid PDO position!\n");
 return -EINVAL;
 }
 data.index = pdo->index;
 data.entry_count = ec_pdo_entry_count(pdo);
 ec_cdev_strcpy(data.name, pdo->name);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 EC_MASTER_ERR(master, "Invalid sync manager index %u!\n",
 data.sync_index);
 return -EINVAL;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(
 &sc->sync_configs[data.sync_index].pdos,
 data.pdo_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Invalid PDO position!\n");
 return -EINVAL;
 }
 if (!(entry = ec_pdo_find_entry_by_pos_const(
 pdo, data.entry_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Entry not found!\n");
 return -EINVAL;
 }
 data.index = entry->index;
 data.subindex = entry->subindex;
 data.bit_length = entry->bit_length;
 ec_cdev_strcpy(data.name, entry->name);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 if (!(req = ec_slave_config_get_sdo_by_pos_const(
 sc, data.sdo_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Invalid SDO position!\n");
 return -EINVAL;
 }
 data.index = req->index;
 data.subindex = req->subindex;
 data.size = req->data_size;
 memcpy(&data.data, req->data,
 min((u32) data.size, (u32) EC_MAX_SDO_DATA_SIZE));
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(
 master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave config %u does not exist!\n",
 data.config_index);
 return -EINVAL;
 }
 if (!(req = ec_slave_config_get_idn_by_pos_const(
 sc, data.idn_pos))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Invalid IDN position!\n");
 return -EINVAL;
 }
 data.drive_no = req->drive_no;
 data.state = req->state;
 data.size = req->data_size;
 memcpy(&data.data, req->data,
 min((u32) data.size, (u32) EC_MAX_IDN_DATA_SIZE));
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(eoe = ec_master_get_eoe_handler_const(master, data.eoe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "EoE handler %u does not exist!\n",
 data.eoe_index);
 return -EINVAL;
 }
 data.rx_bytes = eoe->stats.rx_bytes;
 data.rx_rate = eoe->tx_rate;
 data.tx_queued_frames = eoe->tx_queued_frames;
 data.tx_queue_size = eoe->tx_queue_size;
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 if (IS_ERR(sc))
 return PTR_ERR(sc);
 data.config_index = 0;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 list_for_each_entry(entry, &master->configs, list) {
 if (entry == sc)
 break;
 data.config_index++;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 /* Get the sum of the domains' process data sizes. */
 priv->process_data_size = 0;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 list_for_each_entry(domain, &master->domains, list) {
 priv->process_data_size += ecrt_domain_size(domain);
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (priv->process_data_size) {
 priv->process_data = vmalloc(priv->process_data_size);
 if (!priv->process_data) {
 priv->process_data_size = 0;
 if (copy_from_user(&send_interval, (void __user *) arg,
 sizeof(send_interval))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 ec_master_set_send_interval(master,send_interval);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return 0;
 }
 )
 {
 if (unlikely(!priv->requested))
 return -EPERM;
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 ecrt_master_send(master);
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 return 0;
 }
 /*****************************************************************************/
 )
 {
 if (unlikely(!priv->requested))
 return -EPERM;
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 ecrt_master_receive(master);
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 return 0;
 }
 /*****************************************************************************/
 )
 {
 if (unlikely(!priv->requested))
 return -EPERM;
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 ecrt_master_sync_reference_clock(master);
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 return 0;
 }
 /*****************************************************************************/
 )
 {
 if (unlikely(!priv->requested))
 return -EPERM;
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 ecrt_master_sync_slave_clocks(master);
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 return 0;
 }
 /*****************************************************************************/
 )
 {
 if (unlikely(!priv->requested))
 return -EPERM;
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 ecrt_master_sync_monitor_queue(master);
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 return 0;
 }
 /*****************************************************************************/
 uint32_t time_diff;
 if (unlikely(!priv->requested))
 return -EPERM;
-down(&master->io_sem);
+ec_mutex_lock(&master->io_mutex);
 time_diff = ecrt_master_sync_monitor_process(master);
-up(&master->io_sem);
+ec_mutex_unlock(&master->io_mutex);
 if (copy_to_user((void __user *) arg, &time_diff, sizeof(time_diff)))
 return -EFAULT;
 return 0;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 ret = -EFAULT;
 goto out_return;
 }
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 ret = -EINTR;
 goto out_return;
 }
 if (!(sc = ec_master_get_config(master, data.config_index))) {
 }
 }
 }
 out_up:
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 out_return:
 return ret;
 }
 /*****************************************************************************/
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 ret = -EFAULT;
 goto out_return;
 }
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 ret = -EINTR;
 goto out_return;
 }
 if (!(sc = ec_master_get_config(master, data.config_index))) {
 ecrt_slave_config_watchdog(sc,
 data.watchdog_divider, data.watchdog_intervals);
 out_up:
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 out_return:
 return ret;
 }
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 ret = -EFAULT;
 goto out_return;
 }
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 ret = -EINTR;
 goto out_return;
 }
 if (!(sc = ec_master_get_config(master, data.config_index))) {
 ecrt_slave_config_overlapping_pdos(sc,
 data.allow_overlapping_pdos);
 out_up:
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 out_return:
 return ret;
 }
 /*****************************************************************************/
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem); // FIXME
+ec_mutex_unlock(&master->master_mutex); // FIXME
 return ecrt_slave_config_pdo_assign_add(sc, data.sync_index, data.index);
 }
 /*****************************************************************************/
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem); // FIXME
+ec_mutex_unlock(&master->master_mutex); // FIXME
 ecrt_slave_config_pdo_assign_clear(sc, data.sync_index);
 return 0;
 }
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem); // FIXME
+ec_mutex_unlock(&master->master_mutex); // FIXME
 return ecrt_slave_config_pdo_mapping_add(sc, data.pdo_index,
 data.entry_index, data.entry_subindex, data.entry_bit_length);
 }
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem); // FIXME
+ec_mutex_unlock(&master->master_mutex); // FIXME
 ecrt_slave_config_pdo_mapping_clear(sc, data.index);
 return 0;
 }
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(domain = ec_master_find_domain(master, data.domain_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem); // FIXME
+ec_mutex_unlock(&master->master_mutex); // FIXME
 ret = ecrt_slave_config_reg_pdo_entry(sc, data.entry_index,
 data.entry_subindex, domain, &data.bit_position);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 ecrt_slave_config_dc(sc, data.dc_assign_activate,
 data.dc_sync[0].cycle_time,
 data.dc_sync[0].shift_time,
 data.dc_sync[1].cycle_time,
 data.dc_sync[1].shift_time);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return 0;
 }
 /*****************************************************************************/
 if (copy_from_user(sdo_data, (void __user *) data.data, data.size)) {
 kfree(sdo_data);
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 kfree(sdo_data);
 return -EINTR;
 }
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 kfree(sdo_data);
 return -ENOENT;
 }
-up(&master->master_sem); // FIXME
+ec_mutex_unlock(&master->master_mutex); // FIXME
 if (data.complete_access) {
 ret = ecrt_slave_config_complete_sdo(sc,
 data.index, sdo_data, data.size);
 } else {
 return -EFAULT;
 }
 data.request_index = 0;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 sc = ec_master_get_config(master, data.config_index);
 if (!sc) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 list_for_each_entry(req, &sc->sdo_requests, list) {
 data.request_index++;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 req = ecrt_slave_config_create_sdo_request_err(sc, data.sdo_index,
 data.sdo_subindex, data.size);
 if (IS_ERR(req))
 return PTR_ERR(req);
 return -EFAULT;
 }
 data.voe_index = 0;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 sc = ec_master_get_config(master, data.config_index);
 if (!sc) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 list_for_each_entry(voe, &sc->voe_handlers, list) {
 data.voe_index++;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 voe = ecrt_slave_config_create_voe_handler_err(sc, data.size);
 if (IS_ERR(voe))
 return PTR_ERR(voe);
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config_const(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 ecrt_slave_config_state(sc, &state);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) data.state, &state, sizeof(state)))
 return -EFAULT;
 return 0;
 if (copy_from_user(data, (void __user *) ioctl.data, ioctl.size)) {
 kfree(data);
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 kfree(data);
 return -EINTR;
 }
 if (!(sc = ec_master_get_config(master, ioctl.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 kfree(data);
 return -ENOENT;
 }
-up(&master->master_sem); // FIXME
+ec_mutex_unlock(&master->master_mutex); // FIXME
 ret = ecrt_slave_config_idn(
 sc, ioctl.drive_no, ioctl.idn, ioctl.al_state, data, ioctl.size);
 kfree(data);
 return ret;
 const ec_domain_t *domain;
 if (unlikely(!priv->requested))
 return -EPERM;
-if (down_interruptible(&master->master_sem)) {
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
 return -EINTR;
 }
 list_for_each_entry(domain, &master->domains, list) {
 if (domain->index == arg) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return offset;
 }
 offset += ecrt_domain_size(domain);
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 /*****************************************************************************/
 ec_domain_t *domain;
 if (unlikely(!priv->requested))
 return -EPERM;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(domain = ec_master_find_domain(master, arg))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 ecrt_domain_process(domain);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return 0;
 }
 /*****************************************************************************/
 ec_domain_t *domain;
 if (unlikely(!priv->requested))
 return -EPERM;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(domain = ec_master_find_domain(master, arg))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 ecrt_domain_queue(domain);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return 0;
 }
 /*****************************************************************************/
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 ecrt_domain_state(domain, &state);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) data.state, &state, sizeof(state)))
 return -EFAULT;
 return 0;
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ecrt_sdo_request_timeout(req, data.timeout);
 return 0;
 }
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 data.state = ecrt_sdo_request_state(req);
 if (data.state == EC_REQUEST_SUCCESS && req->dir == EC_DIR_INPUT)
 data.size = ecrt_sdo_request_data_size(req);
 else
 data.size = 0;
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) arg, &data, sizeof(data)))
 return -EFAULT;
 return 0;
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ecrt_sdo_request_read(req);
 return 0;
 }
 if (!data.size) {
 EC_MASTER_ERR(master, "SDO download: Data size may not be zero!\n");
 return -EINVAL;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ret = ec_sdo_request_alloc(req, data.size);
 if (ret)
 return ret;
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(req = ec_slave_config_find_sdo_request(sc, data.request_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) data.data, ecrt_sdo_request_data(req),
 ecrt_sdo_request_data_size(req)))
 return -EFAULT;
 return -EFAULT;
 if (get_user(vendor_type, data.vendor_type))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(voe = ec_slave_config_find_voe_handler(sc, data.voe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ecrt_voe_handler_send_header(voe, vendor_id, vendor_type);
 return 0;
 }
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(voe = ec_slave_config_find_voe_handler(sc, data.voe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 ecrt_voe_handler_received_header(voe, &vendor_id, &vendor_type);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (likely(data.vendor_id))
 if (put_user(vendor_id, data.vendor_id))
 return -EFAULT;
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(voe = ec_slave_config_find_voe_handler(sc, data.voe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ecrt_voe_handler_read(voe);
 return 0;
 }
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(voe = ec_slave_config_find_voe_handler(sc, data.voe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ecrt_voe_handler_read_nosync(voe);
 return 0;
 }
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(voe = ec_slave_config_find_voe_handler(sc, data.voe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (data.size) {
 if (data.size > ec_voe_handler_mem_size(voe))
 return -EOVERFLOW;
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(voe = ec_slave_config_find_voe_handler(sc, data.voe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 data.state = ecrt_voe_handler_execute(voe);
 if (data.state == EC_REQUEST_SUCCESS && voe->dir == EC_DIR_INPUT)
 data.size = ecrt_voe_handler_data_size(voe);
 else
 return -EPERM;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data)))
 return -EFAULT;
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex))
 return -EINTR;
 if (!(sc = ec_master_get_config(master, data.config_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
 if (!(voe = ec_slave_config_find_voe_handler(sc, data.voe_index))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 return -ENOENT;
 }
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 if (copy_to_user((void __user *) data.data, ecrt_voe_handler_data(voe),
 ecrt_voe_handler_data_size(voe)))
 return -EFAULT;
 ec_foe_request_init(&request.req, data.file_name);
 ec_foe_request_read(&request.req);
 ec_foe_request_alloc(&request.req, 10000); // FIXME
-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, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 ec_foe_request_clear(&request.req);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 return -EINVAL;
 }
 // schedule request.
 list_add_tail(&request.list, &request.slave->foe_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_SLAVE_DBG(request.slave, 1, "Scheduled FoE read request.\n");
 // wait for processing through FSM
 if (wait_event_interruptible(request.slave->foe_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_foe_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->foe_queue,
 request.req.state != EC_INT_REQUEST_BUSY);
 return -EFAULT;
 }
 request.req.data_size = data.buffer_size;
 ec_foe_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, data.slave_position))) {
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
 ec_foe_request_clear(&request.req);
 return -EINVAL;
 }
 EC_SLAVE_DBG(request.slave, 1, "Scheduling FoE write request.\n");
 // schedule FoE write request.
 list_add_tail(&request.list, &request.slave->foe_requests);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
 if (wait_event_interruptible(request.slave->foe_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_foe_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->foe_queue,
 request.req.state != EC_INT_REQUEST_BUSY);

changeset 2028	55854f070c4a
parent 2027	ac35f4d38a31
child 2029	5ef6507fc77a