bkinnightskytw
/
ethercat
mirror of https://gitlab.com/bkinnightskytw/ethercat.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Applied 0007-replace-fprintf-calls-with-EC_PRINT_ERR.patch

This commit is contained in:
Florian Pose 2022-06-23 10:31:41 +02:00
parent 234695fe44
commit 6cac716122
8 changed files with 102 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lib/common.c
View File

@ -77,7 +77,7 @@ ec_master_t *ecrt_open_master(unsigned int master_index)
master = malloc(sizeof(ec_master_t));
if (!master) {
fprintf(stderr, "Failed to allocate memory.\n");
EC_PRINT_ERR("Failed to allocate memory.\n");
return 0;
}
@ -100,20 +100,20 @@ ec_master_t *ecrt_open_master(unsigned int master_index)
master->fd = open(path, O_RDWR);
#endif
if (EC_IOCTL_IS_ERROR(master->fd)) {
fprintf(stderr, "Failed to open %s: %s\n", path,
EC_PRINT_ERR("Failed to open %s: %s\n", path,
strerror(EC_IOCTL_ERRNO(master->fd)));
goto out_clear;
}
ret = ioctl(master->fd, EC_IOCTL_MODULE, &module_data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get module information from %s: %s\n",
EC_PRINT_ERR("Failed to get module information from %s: %s\n",
path, strerror(EC_IOCTL_ERRNO(ret)));
goto out_clear;
}
if (module_data.ioctl_version_magic != EC_IOCTL_VERSION_MAGIC) {
fprintf(stderr, "ioctl() version magic is differing:"
EC_PRINT_ERR("ioctl() version magic is differing:"
" %s: %u, libethercat: %u.\n",
path, module_data.ioctl_version_magic,
EC_IOCTL_VERSION_MAGIC);

10
lib/domain.c
View File

@ -82,7 +82,7 @@ size_t ecrt_domain_size(const ec_domain_t *domain)
ret = ioctl(domain->master->fd, EC_IOCTL_DOMAIN_SIZE, domain->index);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get domain size: %s\n",
EC_PRINT_ERR("Failed to get domain size: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
@ -99,7 +99,7 @@ uint8_t *ecrt_domain_data(ec_domain_t *domain)
offset = ioctl(domain->master->fd, EC_IOCTL_DOMAIN_OFFSET,
domain->index);
if (EC_IOCTL_IS_ERROR(offset)) {
fprintf(stderr, "Failed to get domain offset: %s\n",
EC_PRINT_ERR("Failed to get domain offset: %s\n",
strerror(EC_IOCTL_ERRNO(offset)));
return NULL;
}
@ -118,7 +118,7 @@ void ecrt_domain_process(ec_domain_t *domain)
ret = ioctl(domain->master->fd, EC_IOCTL_DOMAIN_PROCESS, domain->index);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to process domain: %s\n",
EC_PRINT_ERR("Failed to process domain: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -131,7 +131,7 @@ void ecrt_domain_queue(ec_domain_t *domain)
ret = ioctl(domain->master->fd, EC_IOCTL_DOMAIN_QUEUE, domain->index);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to queue domain: %s\n",
EC_PRINT_ERR("Failed to queue domain: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -148,7 +148,7 @@ void ecrt_domain_state(const ec_domain_t *domain, ec_domain_state_t *state)
ret = ioctl(domain->master->fd, EC_IOCTL_DOMAIN_STATE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get domain state: %s\n",
EC_PRINT_ERR("Failed to get domain state: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}

10
lib/ioctl.h
View File

@ -53,6 +53,11 @@
#define EC_IOCTL_IS_ERROR(X) ((X) < 0)
#define EC_IOCTL_ERRNO(X) (-(X))
/* print errors to syslog */
#define KERN_ERR "<3>"
#define EC_PRINT_ERR(fmt, args...) \
rt_printk(KERN_ERR "EtherCAT ERROR: " fmt, ##args)
#else
#define ioctl ioctl
@ -61,6 +66,10 @@
#define EC_IOCTL_IS_ERROR(X) ((X) == -1)
#define EC_IOCTL_ERRNO(X) (errno)
/* print errors to stderr */
#define EC_PRINT_ERR(fmt, args...) \
fprintf(stderr, fmt, ##args)
#include <errno.h>
#endif
@ -70,4 +79,3 @@
#endif /* __EC_LIB_IOCTL_H__ */
/*****************************************************************************/

70
lib/master.c
View File

@ -44,7 +44,7 @@ int ecrt_master_reserve(ec_master_t *master)
{
int ret = ioctl(master->fd, EC_IOCTL_REQUEST, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to reserve master: %s\n",
EC_PRINT_ERR("Failed to reserve master: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -128,13 +128,13 @@ ec_domain_t *ecrt_master_create_domain(ec_master_t *master)
domain = malloc(sizeof(ec_domain_t));
if (!domain) {
fprintf(stderr, "Failed to allocate memory.\n");
EC_PRINT_ERR("Failed to allocate memory.\n");
return 0;
}
index = ioctl(master->fd, EC_IOCTL_CREATE_DOMAIN, NULL);
if (EC_IOCTL_IS_ERROR(index)) {
fprintf(stderr, "Failed to create domain: %s\n",
EC_PRINT_ERR("Failed to create domain: %s\n",
strerror(EC_IOCTL_ERRNO(index)));
free(domain);
return 0;
@ -177,7 +177,7 @@ ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,
sc = malloc(sizeof(ec_slave_config_t));
if (!sc) {
fprintf(stderr, "Failed to allocate memory.\n");
EC_PRINT_ERR("Failed to allocate memory.\n");
return 0;
}
@ -188,7 +188,7 @@ ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,
ret = ioctl(master->fd, EC_IOCTL_CREATE_SLAVE_CONFIG, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to create slave config: %s\n",
EC_PRINT_ERR("Failed to create slave config: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
free(sc);
return 0;
@ -225,7 +225,7 @@ int ecrt_master_select_reference_clock(ec_master_t *master,
ret = ioctl(master->fd, EC_IOCTL_SELECT_REF_CLOCK, config_index);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to select reference clock: %s\n",
EC_PRINT_ERR("Failed to select reference clock: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -242,7 +242,7 @@ int ecrt_master(ec_master_t *master, ec_master_info_t *master_info)
ret = ioctl(master->fd, EC_IOCTL_MASTER, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get master info: %s\n",
EC_PRINT_ERR("Failed to get master info: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -266,7 +266,7 @@ int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,
ret = ioctl(master->fd, EC_IOCTL_SLAVE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get slave info: %s\n",
EC_PRINT_ERR("Failed to get slave info: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -316,7 +316,7 @@ int ecrt_master_get_sync_manager(ec_master_t *master, uint16_t slave_position,
ret = ioctl(master->fd, EC_IOCTL_SLAVE_SYNC, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get sync manager information: %s\n",
EC_PRINT_ERR("Failed to get sync manager information: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -350,7 +350,7 @@ int ecrt_master_get_pdo(ec_master_t *master, uint16_t slave_position,
ret = ioctl(master->fd, EC_IOCTL_SLAVE_SYNC_PDO, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get pdo information: %s\n",
EC_PRINT_ERR("Failed to get pdo information: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -382,7 +382,7 @@ int ecrt_master_get_pdo_entry(ec_master_t *master, uint16_t slave_position,
ret = ioctl(master->fd, EC_IOCTL_SLAVE_SYNC_PDO_ENTRY, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get pdo entry information: %s\n",
EC_PRINT_ERR("Failed to get pdo entry information: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -415,7 +415,7 @@ int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position,
if (EC_IOCTL_ERRNO(ret) == EIO && abort_code) {
*abort_code = download.abort_code;
}
fprintf(stderr, "Failed to execute SDO download: %s\n",
EC_PRINT_ERR("Failed to execute SDO download: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -444,7 +444,7 @@ int ecrt_master_sdo_download_complete(ec_master_t *master,
if (EC_IOCTL_ERRNO(ret) == EIO && abort_code) {
*abort_code = download.abort_code;
}
fprintf(stderr, "Failed to execute SDO download: %s\n",
EC_PRINT_ERR("Failed to execute SDO download: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -472,7 +472,7 @@ int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,
if (EC_IOCTL_ERRNO(ret) == EIO && abort_code) {
*abort_code = upload.abort_code;
}
fprintf(stderr, "Failed to execute SDO upload: %s\n",
EC_PRINT_ERR("Failed to execute SDO upload: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -501,7 +501,7 @@ int ecrt_master_write_idn(ec_master_t *master, uint16_t slave_position,
if (EC_IOCTL_ERRNO(ret) == EIO && error_code) {
*error_code = io.error_code;
}
fprintf(stderr, "Failed to write IDN: %s\n",
EC_PRINT_ERR("Failed to write IDN: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -529,7 +529,7 @@ int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position,
if (EC_IOCTL_ERRNO(ret) == EIO && error_code) {
*error_code = io.error_code;
}
fprintf(stderr, "Failed to read IDN: %s\n",
EC_PRINT_ERR("Failed to read IDN: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -547,7 +547,7 @@ int ecrt_master_setup_domain_memory(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_SETUP_DOMAIN_MEMORY, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to activate master: %s\n",
EC_PRINT_ERR("Failed to activate master: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -565,7 +565,7 @@ int ecrt_master_setup_domain_memory(ec_master_t *master)
master->process_data = mmap(0, master->process_data_size,
PROT_READ | PROT_WRITE, MAP_SHARED, master->fd, 0);
if (master->process_data == MAP_FAILED) {
fprintf(stderr, "Failed to map process data: %s\n",
EC_PRINT_ERR("Failed to map process data: %s\n",
strerror(errno));
master->process_data = NULL;
master->process_data_size = 0;
@ -589,7 +589,7 @@ int ecrt_master_activate(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_ACTIVATE, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to activate master: %s\n",
EC_PRINT_ERR("Failed to activate master: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -607,7 +607,7 @@ int ecrt_master_activate(ec_master_t *master)
master->process_data = mmap(0, master->process_data_size,
PROT_READ | PROT_WRITE, MAP_SHARED, master->fd, 0);
if (master->process_data == MAP_FAILED) {
fprintf(stderr, "Failed to map process data: %s\n",
EC_PRINT_ERR("Failed to map process data: %s\n",
strerror(errno));
master->process_data = NULL;
master->process_data_size = 0;
@ -630,7 +630,7 @@ void ecrt_master_deactivate_slaves(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_DEACTIVATE_SLAVES, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to deactivate slaves: %s\n",
EC_PRINT_ERR("Failed to deactivate slaves: %s\n",
strerror(EC_IOCTL_IS_ERROR(ret)));
return;
}
@ -644,7 +644,7 @@ void ecrt_master_deactivate(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_DEACTIVATE, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to deactivate master: %s\n",
EC_PRINT_ERR("Failed to deactivate master: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return;
}
@ -661,7 +661,7 @@ int ecrt_master_set_send_interval(ec_master_t *master,
ret = ioctl(master->fd, EC_IOCTL_SET_SEND_INTERVAL, &send_interval_us);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set send interval: %s\n",
EC_PRINT_ERR("Failed to set send interval: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -678,7 +678,7 @@ size_t ecrt_master_send(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_SEND, &sent_bytes);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to send: %s\n",
EC_PRINT_ERR("Failed to send: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
@ -693,7 +693,7 @@ void ecrt_master_receive(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_RECEIVE, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to receive: %s\n",
EC_PRINT_ERR("Failed to receive: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -706,7 +706,7 @@ void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
ret = ioctl(master->fd, EC_IOCTL_MASTER_STATE, state);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get master state: %s\n",
EC_PRINT_ERR("Failed to get master state: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -724,7 +724,7 @@ int ecrt_master_link_state(const ec_master_t *master, unsigned int dev_idx,
ret = ioctl(master->fd, EC_IOCTL_MASTER_LINK_STATE, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get link state: %s\n",
EC_PRINT_ERR("Failed to get link state: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -743,7 +743,7 @@ void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
ret = ioctl(master->fd, EC_IOCTL_APP_TIME, &time);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set application time: %s\n",
EC_PRINT_ERR("Failed to set application time: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -756,7 +756,7 @@ void ecrt_master_sync_reference_clock(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_SYNC_REF, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to sync reference clock: %s\n",
EC_PRINT_ERR("Failed to sync reference clock: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -773,7 +773,7 @@ void ecrt_master_sync_reference_clock_to(ec_master_t *master,
ret = ioctl(master->fd, EC_IOCTL_SYNC_REF_TO, &time);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to sync reference clock: %s\n",
EC_PRINT_ERR("Failed to sync reference clock: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -786,7 +786,7 @@ void ecrt_master_sync_slave_clocks(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_SYNC_SLAVES, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to sync slave clocks: %s\n",
EC_PRINT_ERR("Failed to sync slave clocks: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -802,7 +802,7 @@ int ecrt_master_reference_clock_time(ec_master_t *master, uint32_t *time)
ret = EC_IOCTL_ERRNO(ret);
if (ret != EIO && ret != ENXIO && ret != EAGAIN) {
// do not log if no refclk or no refclk time yet
fprintf(stderr, "Failed to get reference clock time: %s\n",
EC_PRINT_ERR("Failed to get reference clock time: %s\n",
strerror(ret));
}
return -ret;
@ -819,7 +819,7 @@ void ecrt_master_sync_monitor_queue(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_SYNC_MON_QUEUE, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to queue sync monitor datagram: %s\n",
EC_PRINT_ERR("Failed to queue sync monitor datagram: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -834,7 +834,7 @@ uint32_t ecrt_master_sync_monitor_process(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_SYNC_MON_PROCESS, &time_diff);
if (EC_IOCTL_IS_ERROR(ret)) {
time_diff = 0xffffffff;
fprintf(stderr, "Failed to process sync monitor datagram: %s\n",
EC_PRINT_ERR("Failed to process sync monitor datagram: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
@ -849,7 +849,7 @@ void ecrt_master_reset(ec_master_t *master)
ret = ioctl(master->fd, EC_IOCTL_RESET, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to reset master: %s\n",
EC_PRINT_ERR("Failed to reset master: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}

8
lib/reg_request.c
View File

@ -71,7 +71,7 @@ ec_request_state_t ecrt_reg_request_state(ec_reg_request_t *reg)
ret = ioctl(reg->config->master->fd, EC_IOCTL_REG_REQUEST_STATE, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get register request state: %s\n",
EC_PRINT_ERR("Failed to get register request state: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return EC_REQUEST_ERROR;
}
@ -84,7 +84,7 @@ ec_request_state_t ecrt_reg_request_state(ec_reg_request_t *reg)
ret = ioctl(reg->config->master->fd,
EC_IOCTL_REG_REQUEST_DATA, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get register data: %s\n",
EC_PRINT_ERR("Failed to get register data: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return EC_REQUEST_ERROR;
}
@ -109,7 +109,7 @@ void ecrt_reg_request_write(ec_reg_request_t *reg, uint16_t address,
ret = ioctl(reg->config->master->fd, EC_IOCTL_REG_REQUEST_WRITE, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to command an register write operation: %s\n",
EC_PRINT_ERR("Failed to command an register write operation: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -129,7 +129,7 @@ void ecrt_reg_request_read(ec_reg_request_t *reg, uint16_t address,
ret = ioctl(reg->config->master->fd, EC_IOCTL_REG_REQUEST_READ, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to command an register read operation: %s\n",
EC_PRINT_ERR("Failed to command an register read operation: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}

14
lib/sdo_request.c
View File

@ -67,7 +67,7 @@ void ecrt_sdo_request_index(ec_sdo_request_t *req, uint16_t index,
ret = ioctl(req->config->master->fd, EC_IOCTL_SDO_REQUEST_INDEX, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set SDO request index/subindex: %s\n",
EC_PRINT_ERR("Failed to set SDO request index/subindex: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -85,7 +85,7 @@ void ecrt_sdo_request_timeout(ec_sdo_request_t *req, uint32_t timeout)
ret = ioctl(req->config->master->fd, EC_IOCTL_SDO_REQUEST_TIMEOUT, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set SDO request timeout: %s\n",
EC_PRINT_ERR("Failed to set SDO request timeout: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -116,14 +116,14 @@ ec_request_state_t ecrt_sdo_request_state(ec_sdo_request_t *req)
ret = ioctl(req->config->master->fd, EC_IOCTL_SDO_REQUEST_STATE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get SDO request state: %s\n",
EC_PRINT_ERR("Failed to get SDO request state: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return EC_REQUEST_ERROR;
}
if (data.size) { // new data waiting to be copied
if (req->mem_size < data.size) {
fprintf(stderr, "Received %zu bytes do not fit info SDO data"
EC_PRINT_ERR("Received %zu bytes do not fit info SDO data"
" memory (%zu bytes)!\n", data.size, req->mem_size);
return EC_REQUEST_ERROR;
}
@ -133,7 +133,7 @@ ec_request_state_t ecrt_sdo_request_state(ec_sdo_request_t *req)
ret = ioctl(req->config->master->fd,
EC_IOCTL_SDO_REQUEST_DATA, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get SDO data: %s\n",
EC_PRINT_ERR("Failed to get SDO data: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return EC_REQUEST_ERROR;
}
@ -155,7 +155,7 @@ void ecrt_sdo_request_read(ec_sdo_request_t *req)
ret = ioctl(req->config->master->fd, EC_IOCTL_SDO_REQUEST_READ, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to command an SDO read operation : %s\n",
EC_PRINT_ERR("Failed to command an SDO read operation : %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -174,7 +174,7 @@ void ecrt_sdo_request_write(ec_sdo_request_t *req)
ret = ioctl(req->config->master->fd, EC_IOCTL_SDO_REQUEST_WRITE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to command an SDO write operation : %s\n",
EC_PRINT_ERR("Failed to command an SDO write operation : %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}

60
lib/slave_config.c
View File

@ -94,7 +94,7 @@ int ecrt_slave_config_sync_manager(ec_slave_config_t *sc, uint8_t sync_index,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_SYNC, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to config sync manager: %s\n",
EC_PRINT_ERR("Failed to config sync manager: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -117,7 +117,7 @@ void ecrt_slave_config_watchdog(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_WATCHDOG, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to config watchdog: %s\n",
EC_PRINT_ERR("Failed to config watchdog: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -134,7 +134,7 @@ void ecrt_slave_config_overlapping_pdos(ec_slave_config_t *sc,
data.allow_overlapping_pdos = allow_overlapping_pdos;
if (ioctl(sc->master->fd, EC_IOCTL_SC_OVERLAPPING_IO, &data) == -1) {
fprintf(stderr, "Failed to config overlapping PDOs: %s\n",
EC_PRINT_ERR("Failed to config overlapping PDOs: %s\n",
strerror(errno));
}
}
@ -153,7 +153,7 @@ int ecrt_slave_config_pdo_assign_add(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_ADD_PDO, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to add PDO: %s\n",
EC_PRINT_ERR("Failed to add PDO: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -174,7 +174,7 @@ void ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_CLEAR_PDOS, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to clear PDOs: %s\n",
EC_PRINT_ERR("Failed to clear PDOs: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -196,7 +196,7 @@ int ecrt_slave_config_pdo_mapping_add(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_ADD_ENTRY, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to add PDO entry: %s\n",
EC_PRINT_ERR("Failed to add PDO entry: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -217,7 +217,7 @@ void ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_CLEAR_ENTRIES, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to clear PDO entries: %s\n",
EC_PRINT_ERR("Failed to clear PDO entries: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -243,7 +243,7 @@ int ecrt_slave_config_pdos(ec_slave_config_t *sc,
break;
if (sync_info->index >= EC_MAX_SYNC_MANAGERS) {
fprintf(stderr, "Invalid sync manager index %u!\n",
EC_PRINT_ERR("Invalid sync manager index %u!\n",
sync_info->index);
return -ENOENT;
}
@ -306,7 +306,7 @@ int ecrt_slave_config_reg_pdo_entry(
ret = ioctl(sc->master->fd, EC_IOCTL_SC_REG_PDO_ENTRY, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to register PDO entry: %s\n",
EC_PRINT_ERR("Failed to register PDO entry: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -315,7 +315,7 @@ int ecrt_slave_config_reg_pdo_entry(
*bit_position = data.bit_position;
} else {
if (data.bit_position) {
fprintf(stderr, "PDO entry 0x%04X:%02X does not byte-align "
EC_PRINT_ERR("PDO entry 0x%04X:%02X does not byte-align "
"in config %u:%u.\n", index, subindex,
sc->alias, sc->position);
return -EFAULT;
@ -347,7 +347,7 @@ int ecrt_slave_config_reg_pdo_entry_pos(
ret = ioctl(sc->master->fd, EC_IOCTL_SC_REG_PDO_POS, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to register PDO entry: %s\n",
EC_PRINT_ERR("Failed to register PDO entry: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -356,7 +356,7 @@ int ecrt_slave_config_reg_pdo_entry_pos(
*bit_position = io.bit_position;
} else {
if (io.bit_position) {
fprintf(stderr, "PDO entry %u/%u/%u does not byte-align "
EC_PRINT_ERR("PDO entry %u/%u/%u does not byte-align "
"in config %u:%u.\n", sync_index, pdo_pos, entry_pos,
sc->alias, sc->position);
return -EFAULT;
@ -384,7 +384,7 @@ void ecrt_slave_config_dc(ec_slave_config_t *sc, uint16_t assign_activate,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_DC, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set DC parameters: %s\n",
EC_PRINT_ERR("Failed to set DC parameters: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -406,7 +406,7 @@ int ecrt_slave_config_sdo(ec_slave_config_t *sc, uint16_t index,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_SDO, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to configure SDO: %s\n",
EC_PRINT_ERR("Failed to configure SDO: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -431,7 +431,7 @@ int ecrt_slave_config_complete_sdo(ec_slave_config_t *sc, uint16_t index,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_SDO, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to configure SDO: %s\n",
EC_PRINT_ERR("Failed to configure SDO: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -484,7 +484,7 @@ int ecrt_slave_config_emerg_size(ec_slave_config_t *sc, size_t elements)
ret = ioctl(sc->master->fd, EC_IOCTL_SC_EMERG_SIZE, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set emergency ring size: %s\n",
EC_PRINT_ERR("Failed to set emergency ring size: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -505,7 +505,7 @@ int ecrt_slave_config_emerg_pop(ec_slave_config_t *sc, uint8_t *target)
ret = ioctl(sc->master->fd, EC_IOCTL_SC_EMERG_POP, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
if (EC_IOCTL_ERRNO(ret) != ENOENT) {
fprintf(stderr, "Failed to get emergency message: %s\n",
EC_PRINT_ERR("Failed to get emergency message: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
return -EC_IOCTL_ERRNO(ret);
@ -525,7 +525,7 @@ int ecrt_slave_config_emerg_clear(ec_slave_config_t *sc)
ret = ioctl(sc->master->fd, EC_IOCTL_SC_EMERG_CLEAR, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to clear emergency ring: %s\n",
EC_PRINT_ERR("Failed to clear emergency ring: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -544,7 +544,7 @@ int ecrt_slave_config_emerg_overruns(ec_slave_config_t *sc)
ret = ioctl(sc->master->fd, EC_IOCTL_SC_EMERG_OVERRUNS, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get emergency overruns: %s\n",
EC_PRINT_ERR("Failed to get emergency overruns: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -579,14 +579,14 @@ ec_sdo_request_t *ecrt_slave_config_create_sdo_request(ec_slave_config_t *sc,
req = malloc(sizeof(ec_sdo_request_t));
if (!req) {
fprintf(stderr, "Failed to allocate memory.\n");
EC_PRINT_ERR("Failed to allocate memory.\n");
return 0;
}
if (size) {
req->data = malloc(size);
if (!req->data) {
fprintf(stderr, "Failed to allocate %zu bytes of SDO data"
EC_PRINT_ERR("Failed to allocate %zu bytes of SDO data"
" memory.\n", size);
free(req);
return 0;
@ -602,7 +602,7 @@ ec_sdo_request_t *ecrt_slave_config_create_sdo_request(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_SDO_REQUEST, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to create SDO request: %s\n",
EC_PRINT_ERR("Failed to create SDO request: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
ec_sdo_request_clear(req);
free(req);
@ -649,14 +649,14 @@ ec_reg_request_t *ecrt_slave_config_create_reg_request(ec_slave_config_t *sc,
reg = malloc(sizeof(ec_reg_request_t));
if (!reg) {
fprintf(stderr, "Failed to allocate memory.\n");
EC_PRINT_ERR("Failed to allocate memory.\n");
return NULL;
}
if (size) {
reg->data = malloc(size);
if (!reg->data) {
fprintf(stderr, "Failed to allocate %zu bytes of register data"
EC_PRINT_ERR("Failed to allocate %zu bytes of register data"
" memory.\n", size);
free(reg);
return 0;
@ -670,7 +670,7 @@ ec_reg_request_t *ecrt_slave_config_create_reg_request(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_REG_REQUEST, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to create register request: %s\n",
EC_PRINT_ERR("Failed to create register request: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
ec_reg_request_clear(reg);
free(reg);
@ -714,14 +714,14 @@ ec_voe_handler_t *ecrt_slave_config_create_voe_handler(ec_slave_config_t *sc,
voe = malloc(sizeof(ec_voe_handler_t));
if (!voe) {
fprintf(stderr, "Failed to allocate memory.\n");
EC_PRINT_ERR("Failed to allocate memory.\n");
return 0;
}
if (size) {
voe->data = malloc(size);
if (!voe->data) {
fprintf(stderr, "Failed to allocate %zu bytes of VoE data"
EC_PRINT_ERR("Failed to allocate %zu bytes of VoE data"
" memory.\n", size);
free(voe);
return 0;
@ -735,7 +735,7 @@ ec_voe_handler_t *ecrt_slave_config_create_voe_handler(ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_VOE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to create VoE handler: %s\n",
EC_PRINT_ERR("Failed to create VoE handler: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
ec_voe_handler_clear(voe);
free(voe);
@ -766,7 +766,7 @@ void ecrt_slave_config_state(const ec_slave_config_t *sc,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_STATE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get slave configuration state: %s\n",
EC_PRINT_ERR("Failed to get slave configuration state: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -788,7 +788,7 @@ int ecrt_slave_config_idn(ec_slave_config_t *sc, uint8_t drive_no,
ret = ioctl(sc->master->fd, EC_IOCTL_SC_IDN, &io);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to configure IDN: %s\n",
EC_PRINT_ERR("Failed to configure IDN: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}

16
lib/voe_handler.c
View File

@ -66,7 +66,7 @@ void ecrt_voe_handler_send_header(ec_voe_handler_t *voe, uint32_t vendor_id,
ret = ioctl(voe->config->master->fd, EC_IOCTL_VOE_SEND_HEADER, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set VoE send header: %s\n",
EC_PRINT_ERR("Failed to set VoE send header: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -86,7 +86,7 @@ void ecrt_voe_handler_received_header(const ec_voe_handler_t *voe,
ret = ioctl(voe->config->master->fd, EC_IOCTL_VOE_REC_HEADER, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get received VoE header: %s\n",
EC_PRINT_ERR("Failed to get received VoE header: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -117,7 +117,7 @@ void ecrt_voe_handler_read(ec_voe_handler_t *voe)
ret = ioctl(voe->config->master->fd, EC_IOCTL_VOE_READ, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to initiate VoE reading: %s\n",
EC_PRINT_ERR("Failed to initiate VoE reading: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -134,7 +134,7 @@ void ecrt_voe_handler_read_nosync(ec_voe_handler_t *voe)
ret = ioctl(voe->config->master->fd, EC_IOCTL_VOE_READ_NOSYNC, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to initiate VoE reading: %s\n",
EC_PRINT_ERR("Failed to initiate VoE reading: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -153,7 +153,7 @@ void ecrt_voe_handler_write(ec_voe_handler_t *voe, size_t size)
ret = ioctl(voe->config->master->fd, EC_IOCTL_VOE_WRITE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to initiate VoE writing: %s\n",
EC_PRINT_ERR("Failed to initiate VoE writing: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
}
}
@ -170,14 +170,14 @@ ec_request_state_t ecrt_voe_handler_execute(ec_voe_handler_t *voe)
ret = ioctl(voe->config->master->fd, EC_IOCTL_VOE_EXEC, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to execute VoE handler: %s\n",
EC_PRINT_ERR("Failed to execute VoE handler: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return EC_REQUEST_ERROR;
}
if (data.size) { // new data waiting to be copied
if (voe->mem_size < data.size) {
fprintf(stderr, "Received %zu bytes do not fit info VoE data"
EC_PRINT_ERR("Received %zu bytes do not fit info VoE data"
" memory (%zu bytes)!\n", data.size, voe->mem_size);
return EC_REQUEST_ERROR;
}
@ -186,7 +186,7 @@ ec_request_state_t ecrt_voe_handler_execute(ec_voe_handler_t *voe)
ret = ioctl(voe->config->master->fd, EC_IOCTL_VOE_DATA, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get VoE data: %s\n",
EC_PRINT_ERR("Failed to get VoE data: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return EC_REQUEST_ERROR;
}