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

use int as return type for ecrt_master_* 

See #101
This commit is contained in:
Bjarne von Horn 2024-02-09 10:29:57 +01:00
parent 06b408ef1b
commit 13e99008c3
4 changed files with 120 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/ecrt.h
View File

@ -1027,8 +1027,11 @@ EC_PUBLIC_API int ecrt_master_activate(
* become invalid.
*
* This method should not be called in realtime context.
* \return 0 on success, otherwise negative error code.
* \retval 0 Success.
* \retval -EINVAL Master has not been activated before.
*/
EC_PUBLIC_API void ecrt_master_deactivate(
EC_PUBLIC_API int ecrt_master_deactivate(
ec_master_t *master /**< EtherCAT master. */
);
@ -1056,8 +1059,9 @@ EC_PUBLIC_API int ecrt_master_set_send_interval(
* has returned.
*
* \ingroup ApplicationInterfaceRT
* \return Zero on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_master_send(
EC_PUBLIC_API int ecrt_master_send(
ec_master_t *master /**< EtherCAT master. */
);
@ -1072,19 +1076,23 @@ EC_PUBLIC_API void ecrt_master_send(
* ecrt_master_activate() has returned.
*
* \ingroup ApplicationInterfaceRT
* \return Zero on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_master_receive(
EC_PUBLIC_API int ecrt_master_receive(
ec_master_t *master /**< EtherCAT master. */
);
#ifdef __KERNEL__
/** Sends non-application datagrams.
*
* This method has to be called in the send callback function passed via
* ecrt_master_callbacks() to allow the sending of non-application datagrams.
* \return Zero on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_master_send_ext(
int ecrt_master_send_ext(
ec_master_t *master /**< EtherCAT master. */
);
#endif
/** Reads the current master state.
*
@ -1092,8 +1100,9 @@ EC_PUBLIC_API void ecrt_master_send_ext(
*
* This method returns a global state. For the link-specific states in a
* redundant network topology, use the ecrt_master_link_state() method.
* \return Zero on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_master_state(
EC_PUBLIC_API int ecrt_master_state(
const ec_master_t *master, /**< EtherCAT master. */
ec_master_state_t *state /**< Structure to store the information. */
);
@ -1133,8 +1142,9 @@ EC_PUBLIC_API int ecrt_master_link_state(
* necessary, since the absolute value is not of any interest.
*
* \ingroup ApplicationInterfaceRT
* \return Zero on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_master_application_time(
EC_PUBLIC_API int ecrt_master_application_time(
ec_master_t *master, /**< EtherCAT master. */
uint64_t app_time /**< Application time. */
);
@ -1145,8 +1155,11 @@ EC_PUBLIC_API void ecrt_master_application_time(
* by the last call off ecrt_master_application_time().
*
* \ingroup ApplicationInterfaceRT
* \return Zero on success, otherwise negative error code.
* \retval 0 Success.
* \retval -ENXIO No reference clock found.
*/
EC_PUBLIC_API void ecrt_master_sync_reference_clock(
EC_PUBLIC_API int ecrt_master_sync_reference_clock(
ec_master_t *master /**< EtherCAT master. */
);
@ -1159,8 +1172,11 @@ EC_PUBLIC_API void ecrt_master_sync_reference_clock(
* has returned.
*
* \ingroup ApplicationInterfaceRT
* \return Zero on success, otherwise negative error code.
* \retval 0 Success.
* \retval -ENXIO No reference clock found.
*/
EC_PUBLIC_API void ecrt_master_sync_reference_clock_to(
EC_PUBLIC_API int ecrt_master_sync_reference_clock_to(
ec_master_t *master, /**< EtherCAT master. */
uint64_t sync_time /**< Sync reference clock to this time. */
);
@ -1173,8 +1189,11 @@ EC_PUBLIC_API void ecrt_master_sync_reference_clock_to(
* has returned.
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
* \retval 0 Success.
* \retval -ENXIO No reference clock found.
*/
EC_PUBLIC_API void ecrt_master_sync_slave_clocks(
EC_PUBLIC_API int ecrt_master_sync_slave_clocks(
ec_master_t *master /**< EtherCAT master. */
);
@ -1211,7 +1230,7 @@ EC_PUBLIC_API int ecrt_master_reference_clock_time(
*
* \ingroup ApplicationInterfaceRT
*/
EC_PUBLIC_API void ecrt_master_sync_monitor_queue(
EC_PUBLIC_API int ecrt_master_sync_monitor_queue(
ec_master_t *master /**< EtherCAT master. */
);
@ -1240,8 +1259,9 @@ EC_PUBLIC_API uint32_t ecrt_master_sync_monitor_process(
* activation), because slaves will not be configured before.
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_master_reset(
EC_PUBLIC_API int ecrt_master_reset(
ec_master_t *master /**< EtherCAT master. */
);

64
lib/master.c
View File

@ -605,18 +605,17 @@ int ecrt_master_activate(ec_master_t *master)
/****************************************************************************/
void ecrt_master_deactivate(ec_master_t *master)
int ecrt_master_deactivate(ec_master_t *master)
{
int ret;
ret = ioctl(master->fd, EC_IOCTL_DEACTIVATE, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to deactivate master: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return;
return -EC_IOCTL_ERRNO(ret);
}
ec_master_clear_config(master);
return 0;
}
/****************************************************************************/
@ -628,8 +627,6 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
@ -638,41 +635,41 @@ int ecrt_master_set_send_interval(ec_master_t *master,
/****************************************************************************/
void ecrt_master_send(ec_master_t *master)
int ecrt_master_send(ec_master_t *master)
{
int ret;
ret = ioctl(master->fd, EC_IOCTL_SEND, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to send: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_master_receive(ec_master_t *master)
int ecrt_master_receive(ec_master_t *master)
{
int ret;
ret = ioctl(master->fd, EC_IOCTL_RECEIVE, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to receive: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
int ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
{
int ret;
ret = ioctl(master->fd, EC_IOCTL_MASTER_STATE, state);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get master state: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -698,7 +695,7 @@ int ecrt_master_link_state(const ec_master_t *master, unsigned int dev_idx,
/****************************************************************************/
void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
int ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
{
uint64_t time;
int ret;
@ -707,27 +704,27 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_master_sync_reference_clock(ec_master_t *master)
int ecrt_master_sync_reference_clock(ec_master_t *master)
{
int ret;
ret = ioctl(master->fd, EC_IOCTL_SYNC_REF, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to sync reference clock: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_master_sync_reference_clock_to(ec_master_t *master,
int ecrt_master_sync_reference_clock_to(ec_master_t *master,
uint64_t sync_time)
{
uint64_t time;
@ -737,22 +734,22 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_master_sync_slave_clocks(ec_master_t *master)
int ecrt_master_sync_slave_clocks(ec_master_t *master)
{
int ret;
ret = ioctl(master->fd, EC_IOCTL_SYNC_SLAVES, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to sync slave clocks: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -766,6 +763,7 @@ int ecrt_master_reference_clock_time(const ec_master_t *master,
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to get reference clock time: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return ret;
@ -773,15 +771,15 @@ int ecrt_master_reference_clock_time(const ec_master_t *master,
/****************************************************************************/
void ecrt_master_sync_monitor_queue(ec_master_t *master)
int ecrt_master_sync_monitor_queue(ec_master_t *master)
{
int ret;
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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -803,15 +801,15 @@ uint32_t ecrt_master_sync_monitor_process(const ec_master_t *master)
/****************************************************************************/
void ecrt_master_reset(ec_master_t *master)
int ecrt_master_reset(ec_master_t *master)
{
int ret;
ret = ioctl(master->fd, EC_IOCTL_RESET, NULL);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to reset master: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/

46
master/ioctl.c
View File

@ -1948,8 +1948,7 @@ static ATTRIBUTES int ec_ioctl_deactivate(
if (unlikely(!ctx->requested))
return -EPERM;
ecrt_master_deactivate(master);
return 0;
return ecrt_master_deactivate(master);
}
/****************************************************************************/
@ -1996,6 +1995,8 @@ static ATTRIBUTES int ec_ioctl_send(
ec_ioctl_context_t *ctx /**< Private data structure of file handle. */
)
{
int ret;
if (unlikely(!ctx->requested)) {
return -EPERM;
}
@ -2003,9 +2004,9 @@ static ATTRIBUTES int ec_ioctl_send(
if (ec_ioctl_lock_interruptible(&master->io_mutex))
return -EINTR;
ecrt_master_send(master);
ret = ecrt_master_send(master);
ec_ioctl_unlock(&master->io_mutex);
return 0;
return ret;
}
/****************************************************************************/
@ -2020,6 +2021,8 @@ static ATTRIBUTES int ec_ioctl_receive(
ec_ioctl_context_t *ctx /**< Private data structure of file handle. */
)
{
int ret;
if (unlikely(!ctx->requested)) {
return -EPERM;
}
@ -2027,9 +2030,9 @@ static ATTRIBUTES int ec_ioctl_receive(
if (ec_ioctl_lock_interruptible(&master->io_mutex))
return -EINTR;
ecrt_master_receive(master);
ret = ecrt_master_receive(master);
ec_ioctl_unlock(&master->io_mutex);
return 0;
return ret;
}
/****************************************************************************/
@ -2045,8 +2048,11 @@ static ATTRIBUTES int ec_ioctl_master_state(
)
{
ec_master_state_t data;
int ret;
ecrt_master_state(master, &data);
ret = ecrt_master_state(master, &data);
if (ret)
return ret;
if (ec_copy_to_user((void __user *) arg, &data, sizeof(data), ctx))
return -EFAULT;
@ -2108,8 +2114,7 @@ static ATTRIBUTES int ec_ioctl_app_time(
return -EFAULT;
}
ecrt_master_application_time(master, time);
return 0;
return ecrt_master_application_time(master, time);
}
/****************************************************************************/
@ -2124,6 +2129,8 @@ static ATTRIBUTES int ec_ioctl_sync_ref(
ec_ioctl_context_t *ctx /**< Private data structure of file handle. */
)
{
int ret;
if (unlikely(!ctx->requested)) {
return -EPERM;
}
@ -2131,9 +2138,9 @@ static ATTRIBUTES int ec_ioctl_sync_ref(
if (ec_ioctl_lock_interruptible(&master->io_mutex))
return -EINTR;
ecrt_master_sync_reference_clock(master);
ret = ecrt_master_sync_reference_clock(master);
ec_ioctl_unlock(&master->io_mutex);
return 0;
return ret;
}
/****************************************************************************/
@ -2148,6 +2155,7 @@ static ATTRIBUTES int ec_ioctl_sync_ref_to(
ec_ioctl_context_t *ctx /**< Private data structure of file handle. */
)
{
int ret;
uint64_t time;
if (unlikely(!ctx->requested))
@ -2160,9 +2168,9 @@ static ATTRIBUTES int ec_ioctl_sync_ref_to(
if (ec_ioctl_lock_interruptible(&master->io_mutex))
return -EINTR;
ecrt_master_sync_reference_clock_to(master, time);
ret = ecrt_master_sync_reference_clock_to(master, time);
ec_ioctl_unlock(&master->io_mutex);
return 0;
return ret;
}
/****************************************************************************/
@ -2177,6 +2185,8 @@ static ATTRIBUTES int ec_ioctl_sync_slaves(
ec_ioctl_context_t *ctx /**< Private data structure of file handle. */
)
{
int ret;
if (unlikely(!ctx->requested)) {
return -EPERM;
}
@ -2184,9 +2194,9 @@ static ATTRIBUTES int ec_ioctl_sync_slaves(
if (ec_ioctl_lock_interruptible(&master->io_mutex))
return -EINTR;
ecrt_master_sync_slave_clocks(master);
ret = ecrt_master_sync_slave_clocks(master);
ec_ioctl_unlock(&master->io_mutex);
return 0;
return ret;
}
/****************************************************************************/
@ -2232,6 +2242,8 @@ static ATTRIBUTES int ec_ioctl_sync_mon_queue(
ec_ioctl_context_t *ctx /**< Private data structure of file handle. */
)
{
int ret;
if (unlikely(!ctx->requested)) {
return -EPERM;
}
@ -2239,9 +2251,9 @@ static ATTRIBUTES int ec_ioctl_sync_mon_queue(
if (ec_ioctl_lock_interruptible(&master->io_mutex))
return -EINTR;
ecrt_master_sync_monitor_queue(master);
ret = ecrt_master_sync_monitor_queue(master);
ec_ioctl_unlock(&master->io_mutex);
return 0;
return ret;
}
/****************************************************************************/

42
master/master.c
View File

@ -2350,7 +2350,7 @@ int ecrt_master_activate(ec_master_t *master)
/****************************************************************************/
void ecrt_master_deactivate(ec_master_t *master)
int ecrt_master_deactivate(ec_master_t *master)
{
ec_slave_t *slave;
#ifdef EC_EOE
@ -2362,7 +2362,7 @@ void ecrt_master_deactivate(ec_master_t *master)
if (!master->active) {
EC_MASTER_WARN(master, "%s: Master not active.\n", __func__);
return;
return -EINVAL;
}
ec_master_thread_stop(master);
@ -2416,11 +2416,12 @@ void ecrt_master_deactivate(ec_master_t *master)
master->allow_scan = 0;
master->active = 0;
return 0;
}
/****************************************************************************/
void ecrt_master_send(ec_master_t *master)
int ecrt_master_send(ec_master_t *master)
{
ec_datagram_t *datagram, *n;
ec_device_index_t dev_idx;
@ -2460,11 +2461,12 @@ void ecrt_master_send(ec_master_t *master)
// send frames
ec_master_send_datagrams(master, dev_idx);
}
return 0;
}
/****************************************************************************/
void ecrt_master_receive(ec_master_t *master)
int ecrt_master_receive(ec_master_t *master)
{
unsigned int dev_idx;
ec_datagram_t *datagram, *next;
@ -2512,11 +2514,12 @@ void ecrt_master_receive(ec_master_t *master)
#endif /* RT_SYSLOG */
}
}
return 0;
}
/****************************************************************************/
void ecrt_master_send_ext(ec_master_t *master)
int ecrt_master_send_ext(ec_master_t *master)
{
ec_datagram_t *datagram, *next;
@ -2528,7 +2531,7 @@ void ecrt_master_send_ext(ec_master_t *master)
}
up(&master->ext_queue_sem);
ecrt_master_send(master);
return ecrt_master_send(master);
}
/****************************************************************************/
@ -2727,7 +2730,7 @@ void ecrt_master_callbacks(ec_master_t *master,
/****************************************************************************/
void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
int ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
{
ec_device_index_t dev_idx;
@ -2746,6 +2749,7 @@ void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
/* Signal link up if at least one device has link. */
state->link_up |= master->devices[dev_idx].link_state;
}
return 0;
}
/****************************************************************************/
@ -2766,13 +2770,14 @@ int ecrt_master_link_state(const ec_master_t *master, unsigned int dev_idx,
/****************************************************************************/
void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
int ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
{
master->app_time = app_time;
if (unlikely(!master->dc_ref_time)) {
master->dc_ref_time = app_time;
}
return 0;
}
/****************************************************************************/
@ -2797,17 +2802,20 @@ int ecrt_master_reference_clock_time(const ec_master_t *master,
/****************************************************************************/
void ecrt_master_sync_reference_clock(ec_master_t *master)
int ecrt_master_sync_reference_clock(ec_master_t *master)
{
if (master->dc_ref_clock) {
EC_WRITE_U32(master->ref_sync_datagram.data, master->app_time);
ec_master_queue_datagram(master, &master->ref_sync_datagram);
} else {
return -ENXIO;
}
return 0;
}
/****************************************************************************/
void ecrt_master_sync_reference_clock_to(
int ecrt_master_sync_reference_clock_to(
ec_master_t *master,
uint64_t sync_time
)
@ -2815,25 +2823,32 @@ void ecrt_master_sync_reference_clock_to(
if (master->dc_ref_clock) {
EC_WRITE_U32(master->ref_sync_datagram.data, sync_time);
ec_master_queue_datagram(master, &master->ref_sync_datagram);
} else {
return -ENXIO;
}
return 0;
}
/****************************************************************************/
void ecrt_master_sync_slave_clocks(ec_master_t *master)
int ecrt_master_sync_slave_clocks(ec_master_t *master)
{
if (master->dc_ref_clock) {
ec_datagram_zero(&master->sync_datagram);
ec_master_queue_datagram(master, &master->sync_datagram);
} else {
return -ENXIO;
}
return 0;
}
/****************************************************************************/
void ecrt_master_sync_monitor_queue(ec_master_t *master)
int ecrt_master_sync_monitor_queue(ec_master_t *master)
{
ec_datagram_zero(&master->sync_mon_datagram);
ec_master_queue_datagram(master, &master->sync_mon_datagram);
return 0;
}
/****************************************************************************/
@ -3252,7 +3267,7 @@ int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position,
/****************************************************************************/
void ecrt_master_reset(ec_master_t *master)
int ecrt_master_reset(ec_master_t *master)
{
ec_slave_config_t *sc;
@ -3261,6 +3276,7 @@ void ecrt_master_reset(ec_master_t *master)
ec_slave_request_state(sc->slave, EC_SLAVE_STATE_OP);
}
}
return 0;
}
/****************************************************************************/