From: Graeme Foot <Graeme.Foot@touchcut.com>
Date: Mon Nov 09 16:48:12 2015 +1300

Replacing fprintf(stderr... calls with EC_PRINT_ERR

diff --git a/lib/common.c b/lib/common.c
--- a/lib/common.c
+++ b/lib/common.c
@@ -77,7 +77,7 @@
 
     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 @@
     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);
diff --git a/lib/domain.c b/lib/domain.c
--- a/lib/domain.c
+++ b/lib/domain.c
@@ -82,7 +82,7 @@
 
     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 @@
         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 @@
 
     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 @@
 
     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 @@
 
     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)));
     }
 }
diff --git a/lib/ioctl.h b/lib/ioctl.h
--- a/lib/ioctl.h
+++ b/lib/ioctl.h
@@ -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
diff --git a/lib/master.c b/lib/master.c
--- a/lib/master.c
+++ b/lib/master.c
@@ -46,7 +46,7 @@
 {
     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);
     }
@@ -120,13 +120,13 @@
 
     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;
@@ -169,7 +169,7 @@
 
     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;
     }
 
@@ -180,7 +180,7 @@
 
     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;
@@ -217,7 +217,7 @@
 
     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);
     }
@@ -234,7 +234,7 @@
 
     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);
     }
@@ -258,7 +258,7 @@
 
     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);
     }
@@ -308,7 +308,7 @@
 
     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);
     }
@@ -342,7 +342,7 @@
 
     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);
     }
@@ -374,7 +374,7 @@
 
     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);
     }
@@ -407,7 +407,7 @@
         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);
     }
@@ -436,7 +436,7 @@
         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);
     }
@@ -464,7 +464,7 @@
         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);
     }
@@ -493,7 +493,7 @@
         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);
     }
@@ -521,7 +521,7 @@
         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);
     }
@@ -539,7 +539,7 @@
 
     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);
     }
@@ -556,7 +556,7 @@
         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;
@@ -579,7 +579,7 @@
 
     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;
     }
@@ -596,7 +596,7 @@
 
     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);
     }
@@ -612,7 +612,7 @@
 
     ret = ioctl(master->fd, EC_IOCTL_SEND, NULL);
     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)));
     }
 }
@@ -625,7 +625,7 @@
 
     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)));
     }
 }
@@ -638,7 +638,7 @@
 
     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)));
     }
 }
@@ -656,7 +656,7 @@
 
     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);
     }
@@ -675,7 +675,7 @@
 
     ret = ioctl(master->fd, EC_IOCTL_APP_TIME, &data);
     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)));
     }
 }
@@ -688,7 +688,7 @@
 
     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)));
     }
 }
@@ -701,7 +701,7 @@
 
     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)));
     }
 }
@@ -714,7 +714,7 @@
 
     ret = ioctl(master->fd, EC_IOCTL_REF_CLOCK_TIME, time);
     if (EC_IOCTL_IS_ERROR(ret)) {
-        fprintf(stderr, "Failed to get reference clock time: %s\n",
+        EC_PRINT_ERR("Failed to get reference clock time: %s\n",
                 strerror(EC_IOCTL_ERRNO(ret)));
     }
 
@@ -729,7 +729,7 @@
 
     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)));
     }
 }
@@ -744,7 +744,7 @@
     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)));
     }
 
@@ -759,7 +759,7 @@
 
     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)));
     }
 }
diff --git a/lib/reg_request.c b/lib/reg_request.c
--- a/lib/reg_request.c
+++ b/lib/reg_request.c
@@ -72,7 +72,7 @@
 
     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;
     }
@@ -85,7 +85,7 @@
         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;
         }
@@ -110,7 +110,7 @@
 
     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)));
     }
 }
@@ -130,7 +130,7 @@
 
     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)));
     }
 }
diff --git a/lib/sdo_request.c b/lib/sdo_request.c
--- a/lib/sdo_request.c
+++ b/lib/sdo_request.c
@@ -68,7 +68,7 @@
 
     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)));
     }
 }
@@ -86,7 +86,7 @@
 
     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)));
     }
 }
@@ -117,14 +117,14 @@
 
     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;
         }
@@ -134,7 +134,7 @@
         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;
         }
@@ -156,7 +156,7 @@
 
     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)));
     }
 }
@@ -175,7 +175,7 @@
 
     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)));
     }
 }
diff --git a/lib/slave_config.c b/lib/slave_config.c
--- a/lib/slave_config.c
+++ b/lib/slave_config.c
@@ -90,7 +90,7 @@
 
     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);
     }
@@ -113,7 +113,7 @@
 
     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)));
     }
 }
@@ -132,7 +132,7 @@
 
     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);
     }
@@ -153,7 +153,7 @@
 
     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)));
     }
 }
@@ -175,7 +175,7 @@
 
     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);
     }
@@ -196,7 +196,7 @@
 
     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)));
     }
 }
@@ -222,7 +222,7 @@
             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;
         }
@@ -284,7 +284,7 @@
 
     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);
     }
@@ -293,7 +293,7 @@
         *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;
@@ -325,7 +325,7 @@
 
     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);
     }
@@ -334,7 +334,7 @@
         *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;
@@ -362,7 +362,7 @@
 
     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)));
     }
 }
@@ -384,7 +384,7 @@
 
     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);
     }
@@ -409,7 +409,7 @@
 
     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);
     }
@@ -462,7 +462,7 @@
 
     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);
     }
@@ -483,7 +483,7 @@
     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);
@@ -503,7 +503,7 @@
 
     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);
     }
@@ -522,7 +522,7 @@
 
     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);
     }
@@ -557,14 +557,14 @@
 
     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;
@@ -580,7 +580,7 @@
 
     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);
@@ -627,14 +627,14 @@
 
     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;
@@ -648,7 +648,7 @@
 
     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);
@@ -692,14 +692,14 @@
 
     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;
@@ -713,7 +713,7 @@
 
     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);
@@ -744,7 +744,7 @@
 
     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)));
     }
 }
@@ -766,7 +766,7 @@
 
     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);
     }
diff --git a/lib/voe_handler.c b/lib/voe_handler.c
--- a/lib/voe_handler.c
+++ b/lib/voe_handler.c
@@ -67,7 +67,7 @@
 
     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)));
     }
 }
@@ -87,7 +87,7 @@
 
     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)));
     }
 }
@@ -118,7 +118,7 @@
 
     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)));
     }
 }
@@ -135,7 +135,7 @@
 
     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)));
     }
 }
@@ -154,7 +154,7 @@
 
     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)));
     }
 }
@@ -171,14 +171,14 @@
 
     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;
         }
@@ -187,7 +187,7 @@
 
         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;
         }