etherlabmaster: comparison master/cdev.c

equal deleted inserted replaced

-:4d8c9a441ef6
+:b544025bd696
 )
 {
 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.tx_size = domain->tx_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.slave_config_alias = fmmu->sc->alias;
 data.slave_config_position = fmmu->sc->position;
 data.sync_index = fmmu->sync_index;
 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_master_t *master, /**< EtherCAT master. */
 unsigned long arg /**< ioctl() argument. */
 )
 {
 ec_ioctl_slave_sdo_upload_t data;
-ec_master_sdo_request_t request;
+ec_master_sdo_request_t* request;
 int retval;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-ec_sdo_request_init(&request.req);
+request = kmalloc(sizeof(*request), GFP_KERNEL);
-ec_sdo_request_address(&request.req,
+if (!request)
-data.sdo_index, data.sdo_entry_subindex);
+return -ENOMEM;
-ecrt_sdo_request_read(&request.req);
+kref_init(&request->refcount);
-if (down_interruptible(&master->master_sem))
+ec_sdo_request_init(&request->req);
-return -EINTR;
+ec_sdo_request_address(&request->req,
+data.sdo_index, data.sdo_entry_subindex);
-if (!(request.slave = ec_master_find_slave(
+ecrt_sdo_request_read(&request->req);
+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_sdo_request_clear(&request.req);
 EC_MASTER_ERR(master, "Slave %u does not exist!\n",
 data.slave_position);
-return -EINVAL;
+kref_put(&request->refcount,ec_master_sdo_request_release);
-}
+return -EINVAL;
+}
-EC_SLAVE_DBG(request.slave, 1, "Schedule SDO upload request.\n");
+EC_SLAVE_DBG(request->slave, 1, "Schedule SDO upload request %p.\n",request);
 // schedule request.
-list_add_tail(&request.list, &request.slave->slave_sdo_requests);
+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,
+if (wait_event_interruptible(request->slave->sdo_queue,
-request.req.state != EC_INT_REQUEST_QUEUED)) {
+((request->req.state == EC_INT_REQUEST_SUCCESS) || (request->req.state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
-down(&master->master_sem);
+kref_put(&request->refcount,ec_master_sdo_request_release);
-if (request.req.state == EC_INT_REQUEST_QUEUED) {
+return -EINTR;
-list_del(&request.list);
+}
-up(&master->master_sem);
-ec_sdo_request_clear(&request.req);
+EC_SLAVE_DBG(request->slave, 1, "Finished SDO upload request %p.\n",request);
-return -EINTR;
-}
+data.abort_code = request->req.abort_code;
-// request already processing: interrupt not possible.
-up(&master->master_sem);
+if (request->req.state != EC_INT_REQUEST_SUCCESS) {
-}
-// wait until master FSM has finished processing
-wait_event(request.slave->sdo_queue,
-request.req.state != EC_INT_REQUEST_BUSY);
-EC_SLAVE_DBG(request.slave, 1, "Finished SDO upload request.\n");
-data.abort_code = request.req.abort_code;
-if (request.req.state != EC_INT_REQUEST_SUCCESS) {
 data.data_size = 0;
-if (request.req.errno) {
+if (request->req.errno) {
-retval = -request.req.errno;
+retval = -request->req.errno;
 } else {
 retval = -EIO;
 }
 } else {
-if (request.req.data_size > data.target_size) {
+if (request->req.data_size > data.target_size) {
 EC_MASTER_ERR(master, "Buffer too small.\n");
-ec_sdo_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_sdo_request_release);
 return -EOVERFLOW;
 }
-data.data_size = request.req.data_size;
+data.data_size = request->req.data_size;
 if (copy_to_user((void __user *) data.target,
-request.req.data, data.data_size)) {
+request->req.data, data.data_size)) {
-ec_sdo_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_sdo_request_release);
 return -EFAULT;
 }
 retval = 0;
 }
 if (__copy_to_user((void __user *) arg, &data, sizeof(data))) {
 retval = -EFAULT;
 }
-ec_sdo_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_sdo_request_release);
 return retval;
 }
 /*****************************************************************************/
 ec_master_t *master, /**< EtherCAT master. */
 unsigned long arg /**< ioctl() argument. */
 )
 {
 ec_ioctl_slave_sdo_download_t data;
-ec_master_sdo_request_t request;
+ec_master_sdo_request_t* request;
 int retval;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
 if (!data.data_size) {
 EC_MASTER_ERR(master, "Zero data size!\n");
 return -EINVAL;
 }
-ec_sdo_request_init(&request.req);
+request = kmalloc(sizeof(*request), GFP_KERNEL);
-ec_sdo_request_address(&request.req,
+if (!request)
+return -ENOMEM;
+kref_init(&request->refcount);
+ec_sdo_request_init(&request->req);
+ec_sdo_request_address(&request->req,
 data.sdo_index, data.sdo_entry_subindex);
-if (ec_sdo_request_alloc(&request.req, data.data_size)) {
+if (ec_sdo_request_alloc(&request->req, data.data_size)) {
-ec_sdo_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_sdo_request_release);
 return -ENOMEM;
 }
-if (copy_from_user(request.req.data,
+if (copy_from_user(request->req.data,
 (void __user *) data.data, data.data_size)) {
-ec_sdo_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_sdo_request_release);
 return -EFAULT;
 }
-request.req.data_size = data.data_size;
+request->req.data_size = data.data_size;
-ecrt_sdo_request_write(&request.req);
+ecrt_sdo_request_write(&request->req);
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
-return -EINTR;
+kref_put(&request->refcount,ec_master_sdo_request_release);
+return -EINTR;
-if (!(request.slave = ec_master_find_slave(
+}
+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_sdo_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_sdo_request_release);
 return -EINVAL;
 }
-EC_SLAVE_DBG(request.slave, 1, "Schedule SDO download request.\n");
+EC_SLAVE_DBG(request->slave, 1, "Schedule SDO download request %p.\n",request);
 // schedule request.
-list_add_tail(&request.list, &request.slave->slave_sdo_requests);
+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,
+if (wait_event_interruptible(request->slave->sdo_queue,
-request.req.state != EC_INT_REQUEST_QUEUED)) {
+((request->req.state == EC_INT_REQUEST_SUCCESS) || (request->req.state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
-down(&master->master_sem);
+kref_put(&request->refcount,ec_master_sdo_request_release);
-if (request.req.state == EC_INT_REQUEST_QUEUED) {
+return -EINTR;
-list_del(&request.list);
+}
-up(&master->master_sem);
-ec_sdo_request_clear(&request.req);
+EC_SLAVE_DBG(request->slave, 1, "Finished SDO download request %p.\n",request);
-return -EINTR;
-}
+data.abort_code = request->req.abort_code;
-// request already processing: interrupt not possible.
-up(&master->master_sem);
+if (request->req.state == EC_INT_REQUEST_SUCCESS) {
-}
-// wait until master FSM has finished processing
-wait_event(request.slave->sdo_queue,
-request.req.state != EC_INT_REQUEST_BUSY);
-EC_SLAVE_DBG(request.slave, 1, "Finished SDO download request.\n");
-data.abort_code = request.req.abort_code;
-if (request.req.state == EC_INT_REQUEST_SUCCESS) {
 retval = 0;
-} else if (request.req.errno) {
+} else if (request->req.errno) {
-retval = -request.req.errno;
+retval = -request->req.errno;
 } else {
 retval = -EIO;
 }
 if (__copy_to_user((void __user *) arg, &data, sizeof(data))) {
 retval = -EFAULT;
 }
-ec_sdo_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_sdo_request_release);
 return retval;
 }
 /*****************************************************************************/
 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;
 }
 /*****************************************************************************/
 {
 ec_ioctl_slave_sii_t data;
 ec_slave_t *slave;
 unsigned int byte_size;
 uint16_t *words;
-ec_sii_write_request_t request;
+ec_sii_write_request_t* request;
+int retval;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
 EC_MASTER_ERR(master, "Failed to allocate %u bytes"
 " for SII contents.\n", byte_size);
 return -ENOMEM;
 }
+request = kmalloc(sizeof(*request), GFP_KERNEL);
+if (!request)
+return -ENOMEM;
+kref_init(&request->refcount);
+// init SII write request
+INIT_LIST_HEAD(&request->list);
+request->words = words; // now "owned" by request, see ec_master_sii_write_request_release
+request->offset = data.offset;
+request->nwords = data.nwords;
 if (copy_from_user(words,
 (void __user *) data.words, byte_size)) {
-kfree(words);
+kref_put(&request->refcount,ec_master_sii_write_request_release);
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
-return -EINTR;
+kref_put(&request->refcount,ec_master_sii_write_request_release);
+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);
+kref_put(&request->refcount,ec_master_sii_write_request_release);
 return -EINVAL;
 }
-// init SII write request
+request->slave = slave;
-INIT_LIST_HEAD(&request.list);
+request->state = EC_INT_REQUEST_QUEUED;
-request.slave = slave;
-request.words = words;
-request.offset = data.offset;
-request.nwords = data.nwords;
-request.state = EC_INT_REQUEST_QUEUED;
 // schedule SII write request.
-list_add_tail(&request.list, &master->sii_requests);
+list_add_tail(&request->list, &master->sii_requests);
+kref_get(&request->refcount);
-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)) {
+((request->state == EC_INT_REQUEST_SUCCESS) || (request->state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
-down(&master->master_sem);
+kref_put(&request->refcount,ec_master_sii_write_request_release);
-if (request.state == EC_INT_REQUEST_QUEUED) {
+return -EINTR;
-// abort request
+}
-list_del(&request.list);
-up(&master->master_sem);
-kfree(words);
+retval = request->state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
-return -EINTR;
+kref_put(&request->refcount,ec_master_sii_write_request_release);
-}
-up(&master->master_sem);
+return retval;
-}
-// wait until master FSM has finished processing
-wait_event(master->sii_queue, request.state != EC_INT_REQUEST_BUSY);
-kfree(words);
-return request.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
 }
 /*****************************************************************************/
 /** Read a slave's registers.
 )
 {
 ec_ioctl_slave_reg_t data;
 ec_slave_t *slave;
 uint8_t *contents;
-ec_reg_request_t request;
+ec_reg_request_t* request;
+int retval;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
 EC_MASTER_ERR(master, "Failed to allocate %u bytes"
 " for register data.\n", data.length);
 return -ENOMEM;
 }
-if (down_interruptible(&master->master_sem))
+request = kmalloc(sizeof(*request), GFP_KERNEL);
-return -EINTR;
+if (!request)
+return -ENOMEM;
+kref_init(&request->refcount);
+// init register request
+INIT_LIST_HEAD(&request->list);
+request->dir = EC_DIR_INPUT;
+request->data = contents;   // now "owned" by request, see ec_master_reg_request_release
+request->offset = data.offset;
+request->length = data.length;
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
+kref_put(&request->refcount,ec_master_reg_request_release);
+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;
+kref_put(&request->refcount,ec_master_reg_request_release);
-}
+return -EINVAL;
+}
-// init register request
-INIT_LIST_HEAD(&request.list);
+request->slave = slave;
-request.slave = slave;
+request->state = EC_INT_REQUEST_QUEUED;
-request.dir = EC_DIR_INPUT;
-request.data = contents;
-request.offset = data.offset;
-request.length = data.length;
-request.state = EC_INT_REQUEST_QUEUED;
 // schedule request.
-list_add_tail(&request.list, &master->reg_requests);
+list_add_tail(&request->list, &master->reg_requests);
+kref_get(&request->refcount);
-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)) {
+((request->state == EC_INT_REQUEST_SUCCESS) || (request->state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
-down(&master->master_sem);
+kref_put(&request->refcount,ec_master_reg_request_release);
-if (request.state == EC_INT_REQUEST_QUEUED) {
+return -EINTR;
-// abort request
+}
-list_del(&request.list);
-up(&master->master_sem);
+if (request->state == EC_INT_REQUEST_SUCCESS) {
-kfree(contents);
+if (copy_to_user((void __user *) data.data, request->data, data.length)) {
-return -EINTR;
+kref_put(&request->refcount,ec_master_reg_request_release);
+return -EFAULT;
 }
-up(&master->master_sem);
+}
-}
+retval = request->state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
-// wait until master FSM has finished processing
+kref_put(&request->refcount,ec_master_reg_request_release);
-wait_event(master->reg_queue, request.state != EC_INT_REQUEST_BUSY);
+return retval;
-if (request.state == EC_INT_REQUEST_SUCCESS) {
-if (copy_to_user((void __user *) data.data, contents, data.length))
-return -EFAULT;
-}
-kfree(contents);
-return request.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
 }
 /*****************************************************************************/
 /** Write a slave's registers.
 )
 {
 ec_ioctl_slave_reg_t data;
 ec_slave_t *slave;
 uint8_t *contents;
-ec_reg_request_t request;
+ec_reg_request_t* request;
+int retval;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
 if (copy_from_user(contents, (void __user *) data.data, data.length)) {
 kfree(contents);
 return -EFAULT;
 }
-if (down_interruptible(&master->master_sem))
+request = kmalloc(sizeof(*request), GFP_KERNEL);
-return -EINTR;
+if (!request)
+return -ENOMEM;
+kref_init(&request->refcount);
+// init register request
+INIT_LIST_HEAD(&request->list);
+request->dir = EC_DIR_OUTPUT;
+request->data = contents; // now "owned" by request, see ec_master_reg_request_release
+request->offset = data.offset;
+request->length = data.length;
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
+kref_put(&request->refcount,ec_master_reg_request_release);
+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);
+kref_put(&request->refcount,ec_master_reg_request_release);
 return -EINVAL;
 }
-// init register request
+request->slave = slave;
-INIT_LIST_HEAD(&request.list);
+request->state = EC_INT_REQUEST_QUEUED;
-request.slave = slave;
-request.dir = EC_DIR_OUTPUT;
-request.data = contents;
-request.offset = data.offset;
-request.length = data.length;
-request.state = EC_INT_REQUEST_QUEUED;
 // schedule request.
-list_add_tail(&request.list, &master->reg_requests);
+list_add_tail(&request->list, &master->reg_requests);
+kref_get(&request->refcount);
-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)) {
+((request->state == EC_INT_REQUEST_SUCCESS) || (request->state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
-down(&master->master_sem);
+kref_put(&request->refcount,ec_master_reg_request_release);
-if (request.state == EC_INT_REQUEST_QUEUED) {
+return -EINTR;
-// abort request
+}
-list_del(&request.list);
-up(&master->master_sem);
+retval = request->state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
-kfree(contents);
+kref_put(&request->refcount,ec_master_reg_request_release);
-return -EINTR;
+return retval;
-}
-up(&master->master_sem);
-}
-// wait until master FSM has finished processing
-wait_event(master->reg_queue, request.state != EC_INT_REQUEST_BUSY);
-kfree(contents);
-return request.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
 }
 /*****************************************************************************/
 /** Get slave configuration information.
 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;
 }
 } else {
 data.slave_position = 0xffff;
 }
 snprintf(data.name, EC_DATAGRAM_NAME_SIZE, eoe->dev->name);
 data.open = eoe->opened;
-data.rx_bytes = eoe->stats.tx_bytes;
+data.tx_bytes = eoe->stats.tx_bytes;
+data.tx_rate = eoe->tx_rate;
+data.rx_bytes = eoe->stats.rx_bytes;
 data.rx_rate = eoe->tx_rate;
-data.tx_bytes = eoe->stats.rx_bytes;
-data.tx_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;
 ecrt_domain_external_memory(domain, priv->process_data + offset);
 offset += ecrt_domain_size(domain);
 }
 }
-ecrt_master_callbacks(master, ec_master_internal_send_cb,
-ec_master_internal_receive_cb, master);
 ret = ecrt_master_activate(master);
 if (ret < 0)
 return ret;
 if (copy_to_user((void __user *) arg,
 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;
 }
 /*****************************************************************************/
 return 0;
 }
 /*****************************************************************************/
+/** Get the master state of all configured slaves.
+*/
+int ec_cdev_ioctl_master_sc_state(
+ec_master_t *master, /**< EtherCAT master. */
+unsigned long arg, /**< ioctl() argument. */
+ec_cdev_priv_t *priv /**< Private data structure of file handle. */
+)
+{
+ec_master_state_t data;
+if (unlikely(!priv->requested))
+return -EPERM;
+ecrt_master_configured_slaves_state(master, &data);
+if (copy_to_user((void __user *) arg, &data, sizeof(data)))
+return -EFAULT;
+return 0;
+}
+/*****************************************************************************/
 /** Get the master state.
 */
 int ec_cdev_ioctl_app_time(
 ec_master_t *master, /**< EtherCAT master. */
 unsigned long arg, /**< ioctl() argument. */
 )
 {
 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 (unlikely(!priv->requested))
 return -EPERM;
-down(&master->master_sem);
+ec_mutex_lock(&master->master_mutex);
 ecrt_master_reset(master);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 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;
 }
+/*****************************************************************************/
+/** Configure wether a slave allows overlapping PDOs.
+*/
+int ec_cdev_ioctl_sc_allow_overlapping_pdos(
+ec_master_t *master, /**< EtherCAT master. */
+unsigned long arg, /**< ioctl() argument. */
+ec_cdev_priv_t *priv /**< Private data structure of file handle. */
+)
+{
+ec_ioctl_config_t data;
+ec_slave_config_t *sc;
+int ret = 0;
+if (unlikely(!priv->requested)) {
+ret = -EPERM;
+goto out_return;
+}
+if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
+ret = -EFAULT;
+goto out_return;
+}
+if (ec_mutex_lock_interruptible(&master->master_mutex)) {
+ret = -EINTR;
+goto out_return;
+}
+if (!(sc = ec_master_get_config(master, data.config_index))) {
+ret = -ENOENT;
+goto out_up;
+}
+ecrt_slave_config_overlapping_pdos(sc,
+data.allow_overlapping_pdos);
+out_up:
+ec_mutex_unlock(&master->master_mutex);
+out_return:
+return ret;
+}
 /*****************************************************************************/
 /** Add a PDO to the assignment.
 */
 int ec_cdev_ioctl_sc_add_pdo(
 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_master_t *master, /**< EtherCAT master. */
 unsigned long arg /**< ioctl() argument. */
 )
 {
 ec_ioctl_slave_foe_t data;
-ec_master_foe_request_t request;
+ec_master_foe_request_t* request;
 int retval;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-ec_foe_request_init(&request.req, data.file_name);
+request = kmalloc(sizeof(*request), GFP_KERNEL);
-ec_foe_request_read(&request.req);
+if (!request)
-ec_foe_request_alloc(&request.req, 10000); // FIXME
+return -ENOMEM;
+kref_init(&request->refcount);
-if (down_interruptible(&master->master_sem))
-return -EINTR;
+ec_foe_request_init(&request->req, data.file_name);
+ec_foe_request_read(&request->req);
-if (!(request.slave = ec_master_find_slave(
+ec_foe_request_alloc(&request->req, 10000); // FIXME
+if (ec_mutex_lock_interruptible(&master->master_mutex))  {
+kref_put(&request->refcount,ec_master_foe_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_foe_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_foe_request_release);
 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);
+list_add_tail(&request->list, &request->slave->foe_requests);
+kref_get(&request->refcount);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
-EC_SLAVE_DBG(request.slave, 1, "Scheduled FoE read request.\n");
+EC_SLAVE_DBG(request->slave, 1, "Scheduled FoE read request %p.\n",request);
 // wait for processing through FSM
-if (wait_event_interruptible(request.slave->foe_queue,
+if (wait_event_interruptible(request->slave->foe_queue,
-request.req.state != EC_INT_REQUEST_QUEUED)) {
+((request->req.state == EC_INT_REQUEST_SUCCESS) || (request->req.state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
-down(&master->master_sem);
+kref_put(&request->refcount,ec_master_foe_request_release);
-if (request.req.state == EC_INT_REQUEST_QUEUED) {
+return -EINTR;
-list_del(&request.list);
+}
-up(&master->master_sem);
-ec_foe_request_clear(&request.req);
+data.result = request->req.result;
-return -EINTR;
+data.error_code = request->req.error_code;
-}
-// request already processing: interrupt not possible.
+EC_SLAVE_DBG(request->slave, 1, "Read %zd bytes via FoE"
-up(&master->master_sem);
+" (result = 0x%x).\n", request->req.data_size, request->req.result);
-}
+if (request->req.state != EC_INT_REQUEST_SUCCESS) {
-// wait until master FSM has finished processing
-wait_event(request.slave->foe_queue,
-request.req.state != EC_INT_REQUEST_BUSY);
-data.result = request.req.result;
-data.error_code = request.req.error_code;
-EC_SLAVE_DBG(request.slave, 1, "Read %zd bytes via FoE"
-" (result = 0x%x).\n", request.req.data_size, request.req.result);
-if (request.req.state != EC_INT_REQUEST_SUCCESS) {
 data.data_size = 0;
 retval = -EIO;
 } else {
-if (request.req.data_size > data.buffer_size) {
+if (request->req.data_size > data.buffer_size) {
 EC_MASTER_ERR(master, "Buffer too small.\n");
-ec_foe_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_foe_request_release);
 return -EOVERFLOW;
 }
-data.data_size = request.req.data_size;
+data.data_size = request->req.data_size;
 if (copy_to_user((void __user *) data.buffer,
-request.req.buffer, data.data_size)) {
+request->req.buffer, data.data_size)) {
-ec_foe_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_foe_request_release);
 return -EFAULT;
 }
 retval = 0;
 }
 if (__copy_to_user((void __user *) arg, &data, sizeof(data))) {
 retval = -EFAULT;
 }
-EC_SLAVE_DBG(request.slave, 1, "Finished FoE read request.\n");
+EC_SLAVE_DBG(request->slave, 1, "Finished FoE read request %p.\n",request);
+kref_put(&request->refcount,ec_master_foe_request_release);
-ec_foe_request_clear(&request.req);
 return retval;
 }
 /*****************************************************************************/
 ec_master_t *master, /**< EtherCAT master. */
 unsigned long arg /**< ioctl() argument. */
 )
 {
 ec_ioctl_slave_foe_t data;
-ec_master_foe_request_t request;
+ec_master_foe_request_t* request;
 int retval;
 if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {
 return -EFAULT;
 }
-INIT_LIST_HEAD(&request.list);
+request = kmalloc(sizeof(*request), GFP_KERNEL);
+if (!request)
-ec_foe_request_init(&request.req, data.file_name);
-if (ec_foe_request_alloc(&request.req, data.buffer_size)) {
-ec_foe_request_clear(&request.req);
 return -ENOMEM;
-}
+kref_init(&request->refcount);
-if (copy_from_user(request.req.buffer,
+INIT_LIST_HEAD(&request->list);
+ec_foe_request_init(&request->req, data.file_name);
+if (ec_foe_request_alloc(&request->req, data.buffer_size)) {
+kref_put(&request->refcount,ec_master_foe_request_release);
+return -ENOMEM;
+}
+if (copy_from_user(request->req.buffer,
 (void __user *) data.buffer, data.buffer_size)) {
-ec_foe_request_clear(&request.req);
+kref_put(&request->refcount,ec_master_foe_request_release);
 return -EFAULT;
 }
-request.req.data_size = data.buffer_size;
+request->req.data_size = data.buffer_size;
-ec_foe_request_write(&request.req);
+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(
+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);
+kref_put(&request->refcount,ec_master_foe_request_release);
 return -EINVAL;
 }
-EC_SLAVE_DBG(request.slave, 1, "Scheduling FoE write request.\n");
+EC_SLAVE_DBG(request->slave, 1, "Scheduling FoE write request %p.\n",request);
 // schedule FoE write request.
-list_add_tail(&request.list, &request.slave->foe_requests);
+list_add_tail(&request->list, &request->slave->foe_requests);
+kref_get(&request->refcount);
-up(&master->master_sem);
+ec_mutex_unlock(&master->master_mutex);
 // wait for processing through FSM
-if (wait_event_interruptible(request.slave->foe_queue,
+if (wait_event_interruptible(request->slave->foe_queue,
-request.req.state != EC_INT_REQUEST_QUEUED)) {
+((request->req.state == EC_INT_REQUEST_SUCCESS) || (request->req.state == EC_INT_REQUEST_FAILURE)))) {
 // interrupted by signal
-down(&master->master_sem);
+kref_put(&request->refcount,ec_master_foe_request_release);
-if (request.req.state == EC_INT_REQUEST_QUEUED) {
+return -EINTR;
-// abort request
+}
-list_del(&request.list);
-up(&master->master_sem);
+data.result = request->req.result;
-ec_foe_request_clear(&request.req);
+data.error_code = request->req.error_code;
-return -EINTR;
-}
+retval = request->req.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
-up(&master->master_sem);
-}
-// wait until master FSM has finished processing
-wait_event(request.slave->foe_queue,
-request.req.state != EC_INT_REQUEST_BUSY);
-data.result = request.req.result;
-data.error_code = request.req.error_code;
-retval = request.req.state == EC_INT_REQUEST_SUCCESS ? 0 : -EIO;
 if (__copy_to_user((void __user *) arg, &data, sizeof(data))) {
 retval = -EFAULT;
 }
-ec_foe_request_clear(&request.req);
+EC_SLAVE_DBG(request->slave, 1, "Finished FoE write request %p.\n",request);
+kref_put(&request->refcount,ec_master_foe_request_release);
-EC_SLAVE_DBG(request.slave, 1, "Finished FoE write request.\n");
 return retval;
 }
 /*****************************************************************************/
 if (!(filp->f_mode & FMODE_WRITE))
 return -EPERM;
 return ec_cdev_ioctl_receive(master, arg, priv);
 case EC_IOCTL_MASTER_STATE:
 return ec_cdev_ioctl_master_state(master, arg, priv);
+case EC_IOCTL_MASTER_SC_STATE:
+return ec_cdev_ioctl_master_sc_state(master, arg, priv);
 case EC_IOCTL_APP_TIME:
 if (!(filp->f_mode & FMODE_WRITE))
 return -EPERM;
 return ec_cdev_ioctl_app_time(master, arg, priv);
 case EC_IOCTL_SYNC_REF:
 return ec_cdev_ioctl_sc_sync(master, arg, priv);
 case EC_IOCTL_SC_WATCHDOG:
 if (!(filp->f_mode & FMODE_WRITE))
 return -EPERM;
 return ec_cdev_ioctl_sc_watchdog(master, arg, priv);
+case EC_IOCTL_SC_OVERLAPPING_IO:
+if (!(filp->f_mode & FMODE_WRITE))
+return -EPERM;
+return ec_cdev_ioctl_sc_allow_overlapping_pdos(master,arg,priv);
 case EC_IOCTL_SC_ADD_PDO:
 if (!(filp->f_mode & FMODE_WRITE))
 return -EPERM;
 return ec_cdev_ioctl_sc_add_pdo(master, arg, priv);
 case EC_IOCTL_SC_CLEAR_PDOS:

changeset 2066	b544025bd696
parent 2061	7982704c8599
parent 2042	8b358effa78b
child 2105	86a4a7587c43