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

Merge branch 'int_return_type' into 'devel-1.6' 

use int as return type for all application interface methods

See merge request etherlab.org/ethercat!119
This commit is contained in:
Florian Pose 2024-04-03 08:40:51 +00:00
parent 19a347267c fe160f5c86
commit 6e8119b955
19 changed files with 355 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
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. */
);
@ -1271,8 +1291,10 @@ EC_PUBLIC_API int ecrt_slave_config_sync_manager(
*
* This method has to be called in non-realtime context before
* ecrt_master_activate().
*
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_slave_config_watchdog(
EC_PUBLIC_API int ecrt_slave_config_watchdog(
ec_slave_config_t *sc, /**< Slave configuration. */
uint16_t watchdog_divider, /**< Number of 40 ns intervals (register
0x0400). Used as a base unit for all
@ -1310,8 +1332,9 @@ EC_PUBLIC_API int ecrt_slave_config_pdo_assign_add(
* ecrt_master_activate().
*
* \see ecrt_slave_config_pdos()
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_slave_config_pdo_assign_clear(
EC_PUBLIC_API int ecrt_slave_config_pdo_assign_clear(
ec_slave_config_t *sc, /**< Slave configuration. */
uint8_t sync_index /**< Sync manager index. Must be less
than #EC_MAX_SYNC_MANAGERS. */
@ -1344,8 +1367,9 @@ EC_PUBLIC_API int ecrt_slave_config_pdo_mapping_add(
* ecrt_master_activate().
*
* \see ecrt_slave_config_pdos()
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_slave_config_pdo_mapping_clear(
EC_PUBLIC_API int ecrt_slave_config_pdo_mapping_clear(
ec_slave_config_t *sc, /**< Slave configuration. */
uint16_t pdo_index /**< Index of the PDO. */
);
@ -1492,8 +1516,9 @@ EC_PUBLIC_API int ecrt_slave_config_reg_pdo_entry_pos(
* ecrt_master_activate().
*
* \attention The \a sync1_shift time is ignored.
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_slave_config_dc(
EC_PUBLIC_API int ecrt_slave_config_dc(
ec_slave_config_t *sc, /**< Slave configuration. */
uint16_t assign_activate, /**< AssignActivate word. */
uint32_t sync0_cycle, /**< SYNC0 cycle time [ns]. */
@ -1760,7 +1785,7 @@ EC_PUBLIC_API ec_reg_request_t *ecrt_slave_config_create_reg_request(
*
* \ingroup ApplicationInterfaceRT
*/
EC_PUBLIC_API void ecrt_slave_config_state(
EC_PUBLIC_API int ecrt_slave_config_state(
const ec_slave_config_t *sc, /**< Slave configuration */
ec_slave_config_state_t *state /**< State object to write to. */
);
@ -1901,8 +1926,9 @@ EC_PUBLIC_API uint8_t *ecrt_domain_data(
* ecrt_domain_state() return the result of the last process data exchange.
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_domain_process(
EC_PUBLIC_API int ecrt_domain_process(
ec_domain_t *domain /**< Domain. */
);
@ -1912,8 +1938,9 @@ EC_PUBLIC_API void ecrt_domain_process(
* next call of ecrt_master_send().
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_domain_queue(
EC_PUBLIC_API int ecrt_domain_queue(
ec_domain_t *domain /**< Domain. */
);
@ -1924,8 +1951,9 @@ EC_PUBLIC_API void ecrt_domain_queue(
* Using this method, the process data exchange can be monitored in realtime.
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_domain_state(
EC_PUBLIC_API int ecrt_domain_state(
const ec_domain_t *domain, /**< Domain. */
ec_domain_state_t *state /**< Pointer to a state object to store the
information. */
@ -1946,8 +1974,9 @@ EC_PUBLIC_API void ecrt_domain_state(
* set via ecrt_slave_config_create_sdo_request().
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_sdo_request_index(
EC_PUBLIC_API int ecrt_sdo_request_index(
ec_sdo_request_t *req, /**< SDO request. */
uint16_t index, /**< SDO index. */
uint8_t subindex /**< SDO subindex. */
@ -1963,8 +1992,9 @@ EC_PUBLIC_API void ecrt_sdo_request_index(
*
* The timeout should be defined in non-realtime context, but can also be
* changed afterwards.
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_sdo_request_timeout(
EC_PUBLIC_API int ecrt_sdo_request_timeout(
ec_sdo_request_t *req, /**< SDO request. */
uint32_t timeout /**< Timeout in milliseconds. Zero means no
timeout. */
@ -2047,8 +2077,12 @@ ec_request_state_t ecrt_sdo_request_state(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
* \retval -EINVAL Invalid input data, e.g. data size == 0.
* \retval -ENOBUFS Reserved memory in ecrt_slave_config_create_sdo_request()
* too small.
*/
EC_PUBLIC_API void ecrt_sdo_request_write(
EC_PUBLIC_API int ecrt_sdo_request_write(
ec_sdo_request_t *req /**< SDO request. */
);
@ -2065,8 +2099,9 @@ EC_PUBLIC_API void ecrt_sdo_request_write(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_sdo_request_read(
EC_PUBLIC_API int ecrt_sdo_request_read(
ec_sdo_request_t *req /**< SDO request. */
);
@ -2085,8 +2120,9 @@ EC_PUBLIC_API void ecrt_sdo_request_read(
* set via ecrt_slave_config_create_soe_request().
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_soe_request_idn(
EC_PUBLIC_API int ecrt_soe_request_idn(
ec_soe_request_t *req, /**< IDN request. */
uint8_t drive_no, /**< SDO index. */
uint16_t idn /**< SoE IDN. */
@ -2102,8 +2138,9 @@ EC_PUBLIC_API void ecrt_soe_request_idn(
*
* The timeout should be defined in non-realtime context, but can also be
* changed afterwards.
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_soe_request_timeout(
EC_PUBLIC_API int ecrt_soe_request_timeout(
ec_soe_request_t *req, /**< SoE request. */
uint32_t timeout /**< Timeout in milliseconds. Zero means no
timeout. */
@ -2181,8 +2218,12 @@ EC_PUBLIC_API ec_request_state_t ecrt_soe_request_state(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
* \retval -EINVAL Invalid input data, e.g. data size == 0.
* \retval -ENOBUFS Reserved memory in ecrt_slave_config_create_soe_request()
* too small.
*/
EC_PUBLIC_API void ecrt_soe_request_write(
EC_PUBLIC_API int ecrt_soe_request_write(
ec_soe_request_t *req /**< SoE request. */
);
@ -2199,8 +2240,9 @@ EC_PUBLIC_API void ecrt_soe_request_write(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_soe_request_read(
EC_PUBLIC_API int ecrt_soe_request_read(
ec_soe_request_t *req /**< SoE request. */
);
@ -2220,8 +2262,9 @@ EC_PUBLIC_API void ecrt_soe_request_read(
* change the header later on in realtime context.
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_voe_handler_send_header(
EC_PUBLIC_API int ecrt_voe_handler_send_header(
ec_voe_handler_t *voe, /**< VoE handler. */
uint32_t vendor_id, /**< Vendor ID. */
uint16_t vendor_type /**< Vendor-specific type. */
@ -2239,8 +2282,9 @@ EC_PUBLIC_API void ecrt_voe_handler_send_header(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_voe_handler_received_header(
EC_PUBLIC_API int ecrt_voe_handler_received_header(
const ec_voe_handler_t *voe, /**< VoE handler. */
uint32_t *vendor_id, /**< Vendor ID. */
uint16_t *vendor_type /**< Vendor-specific type. */
@ -2297,8 +2341,11 @@ EC_PUBLIC_API size_t ecrt_voe_handler_data_size(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
* \retval -ENOBUFS Reserved memory in ecrt_slave_config_create_voe_handler
* too small.
*/
EC_PUBLIC_API void ecrt_voe_handler_write(
EC_PUBLIC_API int ecrt_voe_handler_write(
ec_voe_handler_t *voe, /**< VoE handler. */
size_t size /**< Number of bytes to write (without the VoE header). */
);
@ -2322,8 +2369,9 @@ EC_PUBLIC_API void ecrt_voe_handler_write(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_voe_handler_read(
EC_PUBLIC_API int ecrt_voe_handler_read(
ec_voe_handler_t *voe /**< VoE handler. */
);
@ -2347,8 +2395,9 @@ EC_PUBLIC_API void ecrt_voe_handler_read(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
*/
EC_PUBLIC_API void ecrt_voe_handler_read_nosync(
EC_PUBLIC_API int ecrt_voe_handler_read_nosync(
ec_voe_handler_t *voe /**< VoE handler. */
);
@ -2425,8 +2474,11 @@ ec_request_state_t ecrt_reg_request_state(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
* \retval -ENOBUFS Reserved memory in ecrt_slave_config_create_reg_request
* too small.
*/
EC_PUBLIC_API void ecrt_reg_request_write(
EC_PUBLIC_API int ecrt_reg_request_write(
ec_reg_request_t *req, /**< Register request. */
uint16_t address, /**< Register address. */
size_t size /**< Size to write. */
@ -2444,8 +2496,11 @@ EC_PUBLIC_API void ecrt_reg_request_write(
* activation).
*
* \ingroup ApplicationInterfaceRT
* \return 0 on success, otherwise negative error code.
* \retval -ENOBUFS Reserved memory in ecrt_slave_config_create_reg_request
* too small.
*/
EC_PUBLIC_API void ecrt_reg_request_read(
EC_PUBLIC_API int ecrt_reg_request_read(
ec_reg_request_t *req, /**< Register request. */
uint16_t address, /**< Register address. */
size_t size /**< Size to write. */

18
lib/domain.c
View File

@ -90,33 +90,33 @@ uint8_t *ecrt_domain_data(const ec_domain_t *domain)
/****************************************************************************/
void ecrt_domain_process(ec_domain_t *domain)
int ecrt_domain_process(ec_domain_t *domain)
{
int ret;
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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_domain_queue(ec_domain_t *domain)
int ecrt_domain_queue(ec_domain_t *domain)
{
int ret;
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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_domain_state(const ec_domain_t *domain, ec_domain_state_t *state)
int ecrt_domain_state(const ec_domain_t *domain, ec_domain_state_t *state)
{
ec_ioctl_domain_state_t data;
int ret;
@ -126,9 +126,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/

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;
}
/****************************************************************************/

12
lib/reg_request.c
View File

@ -89,7 +89,7 @@ ec_request_state_t ecrt_reg_request_state(const ec_reg_request_t *reg)
/****************************************************************************/
void ecrt_reg_request_write(ec_reg_request_t *reg, uint16_t address,
int ecrt_reg_request_write(ec_reg_request_t *reg, uint16_t address,
size_t size)
{
ec_ioctl_reg_request_t io;
@ -103,14 +103,14 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_reg_request_read(ec_reg_request_t *reg, uint16_t address,
int ecrt_reg_request_read(ec_reg_request_t *reg, uint16_t address,
size_t size)
{
ec_ioctl_reg_request_t io;
@ -123,9 +123,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/

24
lib/sdo_request.c
View File

@ -48,7 +48,7 @@ void ec_sdo_request_clear(ec_sdo_request_t *req)
* Application interface.
****************************************************************************/
void ecrt_sdo_request_index(ec_sdo_request_t *req, uint16_t index,
int ecrt_sdo_request_index(ec_sdo_request_t *req, uint16_t index,
uint8_t subindex)
{
ec_ioctl_sdo_request_t data;
@ -61,14 +61,14 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_sdo_request_timeout(ec_sdo_request_t *req, uint32_t timeout)
int ecrt_sdo_request_timeout(ec_sdo_request_t *req, uint32_t timeout)
{
ec_ioctl_sdo_request_t data;
int ret;
@ -79,9 +79,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -139,7 +139,7 @@ ec_request_state_t ecrt_sdo_request_state(ec_sdo_request_t *req)
/****************************************************************************/
void ecrt_sdo_request_read(ec_sdo_request_t *req)
int ecrt_sdo_request_read(ec_sdo_request_t *req)
{
ec_ioctl_sdo_request_t data;
int ret;
@ -149,14 +149,14 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_sdo_request_write(ec_sdo_request_t *req)
int ecrt_sdo_request_write(ec_sdo_request_t *req)
{
ec_ioctl_sdo_request_t data;
int ret;
@ -168,9 +168,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/

24
lib/slave_config.c
View File

@ -109,7 +109,7 @@ int ecrt_slave_config_sync_manager(ec_slave_config_t *sc, uint8_t sync_index,
/****************************************************************************/
void ecrt_slave_config_watchdog(ec_slave_config_t *sc,
int ecrt_slave_config_watchdog(ec_slave_config_t *sc,
uint16_t divider, uint16_t intervals)
{
ec_ioctl_config_t data;
@ -124,7 +124,9 @@ void ecrt_slave_config_watchdog(ec_slave_config_t *sc,
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to config watchdog: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -151,7 +153,7 @@ int ecrt_slave_config_pdo_assign_add(ec_slave_config_t *sc,
/****************************************************************************/
void ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,
int ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,
uint8_t sync_index)
{
ec_ioctl_config_pdo_t data;
@ -164,7 +166,9 @@ void ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to clear PDOs: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -194,7 +198,7 @@ int ecrt_slave_config_pdo_mapping_add(ec_slave_config_t *sc,
/****************************************************************************/
void ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,
int ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,
uint16_t pdo_index)
{
ec_ioctl_config_pdo_t data;
@ -207,7 +211,9 @@ void ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to clear PDO entries: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -356,7 +362,7 @@ int ecrt_slave_config_reg_pdo_entry_pos(
/****************************************************************************/
void ecrt_slave_config_dc(ec_slave_config_t *sc, uint16_t assign_activate,
int ecrt_slave_config_dc(ec_slave_config_t *sc, uint16_t assign_activate,
uint32_t sync0_cycle_time, int32_t sync0_shift_time,
uint32_t sync1_cycle_time, int32_t sync1_shift_time)
{
@ -372,9 +378,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -813,7 +819,7 @@ ec_voe_handler_t *ecrt_slave_config_create_voe_handler(ec_slave_config_t *sc,
/****************************************************************************/
void ecrt_slave_config_state(const ec_slave_config_t *sc,
int ecrt_slave_config_state(const ec_slave_config_t *sc,
ec_slave_config_state_t *state)
{
ec_ioctl_sc_state_t data;
@ -824,9 +830,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/

24
lib/soe_request.c
View File

@ -48,7 +48,7 @@ void ec_soe_request_clear(ec_soe_request_t *req)
* Application interface.
****************************************************************************/
void ecrt_soe_request_idn(ec_soe_request_t *req, uint8_t drive_no,
int ecrt_soe_request_idn(ec_soe_request_t *req, uint8_t drive_no,
uint16_t idn)
{
ec_ioctl_soe_request_t data;
@ -61,14 +61,14 @@ void ecrt_soe_request_idn(ec_soe_request_t *req, uint8_t drive_no,
ret = ioctl(req->config->master->fd, EC_IOCTL_SOE_REQUEST_IDN, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set SoE request IDN: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_soe_request_timeout(ec_soe_request_t *req, uint32_t timeout)
int ecrt_soe_request_timeout(ec_soe_request_t *req, uint32_t timeout)
{
ec_ioctl_soe_request_t data;
int ret;
@ -79,9 +79,9 @@ void ecrt_soe_request_timeout(ec_soe_request_t *req, uint32_t timeout)
ret = ioctl(req->config->master->fd, EC_IOCTL_SOE_REQUEST_TIMEOUT, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to set SoE request timeout: %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -139,7 +139,7 @@ ec_request_state_t ecrt_soe_request_state(ec_soe_request_t *req)
/****************************************************************************/
void ecrt_soe_request_read(ec_soe_request_t *req)
int ecrt_soe_request_read(ec_soe_request_t *req)
{
ec_ioctl_soe_request_t data;
int ret;
@ -149,14 +149,14 @@ void ecrt_soe_request_read(ec_soe_request_t *req)
ret = ioctl(req->config->master->fd, EC_IOCTL_SOE_REQUEST_READ, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to command an SoE read operation : %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_soe_request_write(ec_soe_request_t *req)
int ecrt_soe_request_write(ec_soe_request_t *req)
{
ec_ioctl_soe_request_t data;
int ret;
@ -168,9 +168,9 @@ void ecrt_soe_request_write(ec_soe_request_t *req)
ret = ioctl(req->config->master->fd, EC_IOCTL_SOE_REQUEST_WRITE, &data);
if (EC_IOCTL_IS_ERROR(ret)) {
fprintf(stderr, "Failed to command an SDO write operation : %s\n",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/

30
lib/voe_handler.c
View File

@ -46,7 +46,7 @@ void ec_voe_handler_clear(ec_voe_handler_t *voe)
/****************************************************************************/
void ecrt_voe_handler_send_header(ec_voe_handler_t *voe, uint32_t vendor_id,
int ecrt_voe_handler_send_header(ec_voe_handler_t *voe, uint32_t vendor_id,
uint16_t vendor_type)
{
ec_ioctl_voe_t data;
@ -59,14 +59,14 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_voe_handler_received_header(const ec_voe_handler_t *voe,
int ecrt_voe_handler_received_header(const ec_voe_handler_t *voe,
uint32_t *vendor_id, uint16_t *vendor_type)
{
ec_ioctl_voe_t data;
@ -79,9 +79,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
@ -100,7 +100,7 @@ size_t ecrt_voe_handler_data_size(const ec_voe_handler_t *voe)
/****************************************************************************/
void ecrt_voe_handler_read(ec_voe_handler_t *voe)
int ecrt_voe_handler_read(ec_voe_handler_t *voe)
{
ec_ioctl_voe_t data;
int ret;
@ -110,14 +110,14 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_voe_handler_read_nosync(ec_voe_handler_t *voe)
int ecrt_voe_handler_read_nosync(ec_voe_handler_t *voe)
{
ec_ioctl_voe_t data;
int ret;
@ -127,14 +127,14 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/
void ecrt_voe_handler_write(ec_voe_handler_t *voe, size_t size)
int ecrt_voe_handler_write(ec_voe_handler_t *voe, size_t size)
{
ec_ioctl_voe_t data;
int ret;
@ -146,9 +146,9 @@ 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",
strerror(EC_IOCTL_ERRNO(ret)));
return -EC_IOCTL_ERRNO(ret);
}
return 0;
}
/****************************************************************************/

9
master/domain.c
View File

@ -447,7 +447,7 @@ uint8_t *ecrt_domain_data(const ec_domain_t *domain)
/****************************************************************************/
void ecrt_domain_process(ec_domain_t *domain)
int ecrt_domain_process(ec_domain_t *domain)
{
uint16_t wc_sum[EC_MAX_NUM_DEVICES] = {}, wc_total;
ec_datagram_pair_t *pair;
@ -633,11 +633,12 @@ void ecrt_domain_process(ec_domain_t *domain)
domain->working_counter_changes = 0;
}
#endif
return 0;
}
/****************************************************************************/
void ecrt_domain_queue(ec_domain_t *domain)
int ecrt_domain_queue(ec_domain_t *domain)
{
ec_datagram_pair_t *datagram_pair;
ec_device_index_t dev_idx;
@ -663,11 +664,12 @@ void ecrt_domain_queue(ec_domain_t *domain)
&datagram_pair->datagrams[dev_idx]);
}
}
return 0;
}
/****************************************************************************/
void ecrt_domain_state(const ec_domain_t *domain, ec_domain_state_t *state)
int ecrt_domain_state(const ec_domain_t *domain, ec_domain_state_t *state)
{
unsigned int dev_idx;
uint16_t wc = 0;
@ -690,6 +692,7 @@ void ecrt_domain_state(const ec_domain_t *domain, ec_domain_state_t *state)
}
state->redundancy_active = domain->redundancy_active;
return 0;
}
/****************************************************************************/

4
master/fsm_coe.c
View File

@ -1309,7 +1309,7 @@ void ec_fsm_coe_down_start(
if (slave->configured_rx_mailbox_size <
EC_MBOX_HEADER_SIZE + EC_COE_DOWN_REQ_HEADER_SIZE) {
EC_SLAVE_ERR(slave, "Mailbox too small!\n");
request->errno = EOVERFLOW;
request->errno = ENOBUFS;
fsm->state = ec_fsm_coe_error;
return;
}
@ -2463,7 +2463,7 @@ void ec_fsm_coe_up_seg_response(
EC_SLAVE_ERR(slave, "SDO upload 0x%04X:%02X failed: Fragment"
" exceeding complete size!\n",
request->index, request->subindex);
request->errno = EOVERFLOW;
request->errno = ENOBUFS;
fsm->state = ec_fsm_coe_error;
return;
}

146
master/ioctl.c
View File

@ -1069,7 +1069,10 @@ static ATTRIBUTES int ec_ioctl_slave_reg_read(
return ret;
}
ecrt_reg_request_read(&request, io.address, io.size);
ret = ecrt_reg_request_read(&request, io.address, io.size);
if (ret) {
return ret;
}
if (down_interruptible(&master->master_sem)) {
ec_reg_request_clear(&request);
@ -1153,7 +1156,10 @@ static ATTRIBUTES int ec_ioctl_slave_reg_write(
return -EFAULT;
}
ecrt_reg_request_write(&request, io.address, io.size);
ret = ecrt_reg_request_write(&request, io.address, io.size);
if (ret) {
return ret;
}
if (down_interruptible(&master->master_sem)) {
ec_reg_request_clear(&request);
@ -1948,8 +1954,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 +2001,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 +2010,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 +2027,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 +2036,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 +2054,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 +2120,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 +2135,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 +2144,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 +2161,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 +2174,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 +2191,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 +2200,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 +2248,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 +2257,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;
}
/****************************************************************************/
@ -2380,7 +2398,7 @@ static ATTRIBUTES int ec_ioctl_sc_watchdog(
goto out_up;
}
ecrt_slave_config_watchdog(sc,
ret = ecrt_slave_config_watchdog(sc,
data.watchdog_divider, data.watchdog_intervals);
out_up:
@ -2454,8 +2472,7 @@ static ATTRIBUTES int ec_ioctl_sc_clear_pdos(
up(&master->master_sem); /** \todo sc could be invalidated */
ecrt_slave_config_pdo_assign_clear(sc, data.sync_index);
return 0;
return ecrt_slave_config_pdo_assign_clear(sc, data.sync_index);
}
/****************************************************************************/
@ -2524,8 +2541,7 @@ static ATTRIBUTES int ec_ioctl_sc_clear_entries(
up(&master->master_sem); /** \todo sc could be invalidated */
ecrt_slave_config_pdo_mapping_clear(sc, data.index);
return 0;
return ecrt_slave_config_pdo_mapping_clear(sc, data.index);
}
/****************************************************************************/
@ -2639,6 +2655,7 @@ static ATTRIBUTES int ec_ioctl_sc_dc(
{
ec_ioctl_config_t data;
ec_slave_config_t *sc;
int ret;
if (unlikely(!ctx->requested))
return -EPERM;
@ -2654,7 +2671,7 @@ static ATTRIBUTES int ec_ioctl_sc_dc(
return -ENOENT;
}
ecrt_slave_config_dc(sc, data.dc_assign_activate,
ret = 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,
@ -2662,7 +2679,7 @@ static ATTRIBUTES int ec_ioctl_sc_dc(
up(&master->master_sem);
return 0;
return ret;
}
/****************************************************************************/
@ -3107,6 +3124,7 @@ static ATTRIBUTES int ec_ioctl_sc_state(
ec_ioctl_sc_state_t data;
const ec_slave_config_t *sc;
ec_slave_config_state_t state;
int ret;
if (unlikely(!ctx->requested))
return -EPERM;
@ -3122,7 +3140,9 @@ static ATTRIBUTES int ec_ioctl_sc_state(
return -ENOENT;
}
ecrt_slave_config_state(sc, &state);
ret = ecrt_slave_config_state(sc, &state);
if (ret)
return ret;
if (ec_copy_to_user((void __user *) data.state,
&state, sizeof(state), ctx))
@ -3334,8 +3354,7 @@ static ATTRIBUTES int ec_ioctl_domain_process(
return -ENOENT;
}
ecrt_domain_process(domain);
return 0;
return ecrt_domain_process(domain);
}
/****************************************************************************/
@ -3351,6 +3370,7 @@ static ATTRIBUTES int ec_ioctl_domain_queue(
)
{
ec_domain_t *domain;
int ret;
if (unlikely(!ctx->requested))
return -EPERM;
@ -3365,9 +3385,9 @@ static ATTRIBUTES int ec_ioctl_domain_queue(
if (ec_ioctl_lock_interruptible(&master->io_mutex))
return -EINTR;
ecrt_domain_queue(domain);
ret = ecrt_domain_queue(domain);
ec_ioctl_unlock(&master->io_mutex);
return 0;
return ret;
}
/****************************************************************************/
@ -3385,6 +3405,7 @@ static ATTRIBUTES int ec_ioctl_domain_state(
ec_ioctl_domain_state_t data;
const ec_domain_t *domain;
ec_domain_state_t state;
int ret;
if (unlikely(!ctx->requested))
return -EPERM;
@ -3400,7 +3421,9 @@ static ATTRIBUTES int ec_ioctl_domain_state(
return -ENOENT;
}
ecrt_domain_state(domain, &state);
ret = ecrt_domain_state(domain, &state);
if (ret)
return ret;
if (ec_copy_to_user((void __user *) data.state, &state, sizeof(state),
ctx))
@ -3442,8 +3465,7 @@ static ATTRIBUTES int ec_ioctl_sdo_request_index(
return -ENOENT;
}
ecrt_sdo_request_index(req, data.sdo_index, data.sdo_subindex);
return 0;
return ecrt_sdo_request_index(req, data.sdo_index, data.sdo_subindex);
}
/****************************************************************************/
@ -3479,8 +3501,7 @@ static ATTRIBUTES int ec_ioctl_sdo_request_timeout(
return -ENOENT;
}
ecrt_sdo_request_timeout(req, data.timeout);
return 0;
return ecrt_sdo_request_timeout(req, data.timeout);
}
/****************************************************************************/
@ -3563,8 +3584,7 @@ static ATTRIBUTES int ec_ioctl_sdo_request_read(
return -ENOENT;
}
ecrt_sdo_request_read(req);
return 0;
return ecrt_sdo_request_read(req);
}
/****************************************************************************/
@ -3606,15 +3626,14 @@ static ATTRIBUTES int ec_ioctl_sdo_request_write(
}
if (data.size > req->mem_size)
return -ENOMEM;
return -ENOBUFS;
if (ec_copy_from_user(req->data, (void __user *) data.data,
data.size, ctx))
return -EFAULT;
req->data_size = data.size;
ecrt_sdo_request_write(req);
return 0;
return ecrt_sdo_request_write(req);
}
/****************************************************************************/
@ -3690,8 +3709,7 @@ static ATTRIBUTES int ec_ioctl_soe_request_index(
return -ENOENT;
}
ecrt_soe_request_idn(req, data.drive_no, data.idn);
return 0;
return ecrt_soe_request_idn(req, data.drive_no, data.idn);
}
/****************************************************************************/
@ -3727,8 +3745,7 @@ static ATTRIBUTES int ec_ioctl_soe_request_timeout(
return -ENOENT;
}
ecrt_soe_request_timeout(req, data.timeout);
return 0;
return ecrt_soe_request_timeout(req, data.timeout);
}
/****************************************************************************/
@ -3811,8 +3828,7 @@ static ATTRIBUTES int ec_ioctl_soe_request_read(
return -ENOENT;
}
ecrt_soe_request_read(req);
return 0;
return ecrt_soe_request_read(req);
}
/****************************************************************************/
@ -3854,15 +3870,14 @@ static ATTRIBUTES int ec_ioctl_soe_request_write(
}
if (data.size > req->mem_size)
return -ENOMEM;
return -ENOBUFS;
if (ec_copy_from_user(req->data, (void __user *) data.data,
data.size, ctx))
return -EFAULT;
req->data_size = data.size;
ecrt_soe_request_write(req);
return 0;
return ecrt_soe_request_write(req);
}
/****************************************************************************/
@ -4033,7 +4048,7 @@ static ATTRIBUTES int ec_ioctl_reg_request_write(
}
if (io.transfer_size > reg->mem_size) {
return -EOVERFLOW;
return -ENOBUFS;
}
if (ec_copy_from_user(reg->data, (void __user *) io.data,
@ -4041,8 +4056,7 @@ static ATTRIBUTES int ec_ioctl_reg_request_write(
return -EFAULT;
}
ecrt_reg_request_write(reg, io.address, io.transfer_size);
return 0;
return ecrt_reg_request_write(reg, io.address, io.transfer_size);
}
/****************************************************************************/
@ -4081,11 +4095,10 @@ static ATTRIBUTES int ec_ioctl_reg_request_read(
}
if (io.transfer_size > reg->mem_size) {
return -EOVERFLOW;
return -ENOBUFS;
}
ecrt_reg_request_read(reg, io.address, io.transfer_size);
return 0;
return ecrt_reg_request_read(reg, io.address, io.transfer_size);
}
/****************************************************************************/
@ -4130,8 +4143,7 @@ static ATTRIBUTES int ec_ioctl_voe_send_header(
return -ENOENT;
}
ecrt_voe_handler_send_header(voe, vendor_id, vendor_type);
return 0;
return ecrt_voe_handler_send_header(voe, vendor_id, vendor_type);
}
/****************************************************************************/
@ -4151,6 +4163,7 @@ static ATTRIBUTES int ec_ioctl_voe_rec_header(
ec_voe_handler_t *voe;
uint32_t vendor_id;
uint16_t vendor_type;
int ret;
if (unlikely(!ctx->requested))
return -EPERM;
@ -4169,7 +4182,9 @@ static ATTRIBUTES int ec_ioctl_voe_rec_header(
return -ENOENT;
}
ecrt_voe_handler_received_header(voe, &vendor_id, &vendor_type);
ret = ecrt_voe_handler_received_header(voe, &vendor_id, &vendor_type);
if (ret)
return ret;
if (likely(data.vendor_id))
if (ec_copy_to_user(data.vendor_id, &vendor_id,
@ -4217,8 +4232,7 @@ static ATTRIBUTES int ec_ioctl_voe_read(
return -ENOENT;
}
ecrt_voe_handler_read(voe);
return 0;
return ecrt_voe_handler_read(voe);
}
/****************************************************************************/
@ -4254,8 +4268,7 @@ static ATTRIBUTES int ec_ioctl_voe_read_nosync(
return -ENOENT;
}
ecrt_voe_handler_read_nosync(voe);
return 0;
return ecrt_voe_handler_read_nosync(voe);
}
/****************************************************************************/
@ -4293,15 +4306,14 @@ static ATTRIBUTES int ec_ioctl_voe_write(
if (data.size) {
if (data.size > ec_voe_handler_mem_size(voe))
return -EOVERFLOW;
return -ENOBUFS;
if (ec_copy_from_user(ecrt_voe_handler_data(voe),
(void __user *) data.data, data.size, ctx))
return -EFAULT;
}
ecrt_voe_handler_write(voe, data.size);
return 0;
return ecrt_voe_handler_write(voe, data.size);
}
/****************************************************************************/
@ -4470,7 +4482,7 @@ static ATTRIBUTES int ec_ioctl_slave_foe_read(
if (request.data_size > io.buffer_size) {
EC_SLAVE_ERR(slave, "%s(): Buffer too small.\n", __func__);
ec_foe_request_clear(&request);
return -EOVERFLOW;
return -ENOBUFS;
}
io.data_size = request.data_size;
if (copy_to_user((void __user *) io.buffer,

2
master/mailbox.c
View File

@ -60,7 +60,7 @@ uint8_t *ec_slave_mbox_prepare_send(const ec_slave_t *slave, /**< slave */
if (unlikely(total_size > slave->configured_rx_mailbox_size)) {
EC_SLAVE_ERR(slave, "Data size (%zu) does not fit in mailbox (%u)!\n",
total_size, slave->configured_rx_mailbox_size);
return ERR_PTR(-EOVERFLOW);
return ERR_PTR(-ENOBUFS);
}
ret = ec_datagram_fpwr(datagram, slave->station_address,

46
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;
}
/****************************************************************************/
@ -3077,7 +3092,7 @@ int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,
} else {
if (request.data_size > target_size) {
EC_SLAVE_ERR(slave, "%s(): Buffer too small.\n", __func__);
ret = -EOVERFLOW;
ret = -ENOBUFS;
}
else {
memcpy(target, request.data, request.data_size);
@ -3235,7 +3250,7 @@ int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position,
} else { // success
if (request.data_size > target_size) {
EC_SLAVE_ERR(slave, "%s(): Buffer too small.\n", __func__);
ret = -EOVERFLOW;
ret = -ENOBUFS;
}
else { // data fits in buffer
if (result_size) {
@ -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;
}
/****************************************************************************/

6
master/reg_request.c
View File

@ -89,24 +89,26 @@ ec_request_state_t ecrt_reg_request_state(const ec_reg_request_t *reg)
/****************************************************************************/
void ecrt_reg_request_write(ec_reg_request_t *reg, uint16_t address,
int ecrt_reg_request_write(ec_reg_request_t *reg, uint16_t address,
size_t size)
{
reg->dir = EC_DIR_OUTPUT;
reg->address = address;
reg->transfer_size = min(size, reg->mem_size);
reg->state = EC_INT_REQUEST_QUEUED;
return 0;
}
/****************************************************************************/
void ecrt_reg_request_read(ec_reg_request_t *reg, uint16_t address,
int ecrt_reg_request_read(ec_reg_request_t *reg, uint16_t address,
size_t size)
{
reg->dir = EC_DIR_INPUT;
reg->address = address;
reg->transfer_size = min(size, reg->mem_size);
reg->state = EC_INT_REQUEST_QUEUED;
return 0;
}
/****************************************************************************/

12
master/sdo_request.c
View File

@ -178,18 +178,20 @@ int ec_sdo_request_timed_out(const ec_sdo_request_t *req /**< SDO request. */)
* Application interface.
****************************************************************************/
void ecrt_sdo_request_index(ec_sdo_request_t *req, uint16_t index,
int ecrt_sdo_request_index(ec_sdo_request_t *req, uint16_t index,
uint8_t subindex)
{
req->index = index;
req->subindex = subindex;
return 0;
}
/****************************************************************************/
void ecrt_sdo_request_timeout(ec_sdo_request_t *req, uint32_t timeout)
int ecrt_sdo_request_timeout(ec_sdo_request_t *req, uint32_t timeout)
{
req->issue_timeout = timeout;
return 0;
}
/****************************************************************************/
@ -215,24 +217,26 @@ ec_request_state_t ecrt_sdo_request_state(const ec_sdo_request_t *req)
/****************************************************************************/
void ecrt_sdo_request_read(ec_sdo_request_t *req)
int ecrt_sdo_request_read(ec_sdo_request_t *req)
{
req->dir = EC_DIR_INPUT;
req->state = EC_INT_REQUEST_QUEUED;
req->errno = 0;
req->abort_code = 0x00000000;
req->jiffies_start = jiffies;
return 0;
}
/****************************************************************************/
void ecrt_sdo_request_write(ec_sdo_request_t *req)
int ecrt_sdo_request_write(ec_sdo_request_t *req)
{
req->dir = EC_DIR_OUTPUT;
req->state = EC_INT_REQUEST_QUEUED;
req->errno = 0;
req->abort_code = 0x00000000;
req->jiffies_start = jiffies;
return 0;
}
/****************************************************************************/

17
master/slave_config.c
View File

@ -647,7 +647,7 @@ int ecrt_slave_config_sync_manager(ec_slave_config_t *sc, uint8_t sync_index,
/****************************************************************************/
void ecrt_slave_config_watchdog(ec_slave_config_t *sc,
int ecrt_slave_config_watchdog(ec_slave_config_t *sc,
uint16_t divider, uint16_t intervals)
{
EC_CONFIG_DBG(sc, 1, "%s(sc = 0x%p, divider = %u, intervals = %u)\n",
@ -655,6 +655,7 @@ void ecrt_slave_config_watchdog(ec_slave_config_t *sc,
sc->watchdog_divider = divider;
sc->watchdog_intervals = intervals;
return 0;
}
/****************************************************************************/
@ -689,7 +690,7 @@ int ecrt_slave_config_pdo_assign_add(ec_slave_config_t *sc,
/****************************************************************************/
void ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,
int ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,
uint8_t sync_index)
{
EC_CONFIG_DBG(sc, 1, "%s(sc = 0x%p, sync_index = %u)\n",
@ -697,12 +698,13 @@ void ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,
if (sync_index >= EC_MAX_SYNC_MANAGERS) {
EC_CONFIG_ERR(sc, "Invalid sync manager index %u!\n", sync_index);
return;
return -EINVAL;
}
down(&sc->master->master_sem);
ec_pdo_list_clear_pdos(&sc->sync_configs[sync_index].pdos);
up(&sc->master->master_sem);
return 0;
}
/****************************************************************************/
@ -744,7 +746,7 @@ int ecrt_slave_config_pdo_mapping_add(ec_slave_config_t *sc,
/****************************************************************************/
void ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,
int ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,
uint16_t pdo_index)
{
uint8_t sync_index;
@ -765,6 +767,7 @@ void ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,
} else {
EC_CONFIG_WARN(sc, "PDO 0x%04X is not assigned.\n", pdo_index);
}
return 0;
}
/****************************************************************************/
@ -956,7 +959,7 @@ int ecrt_slave_config_reg_pdo_entry_pos(
/****************************************************************************/
void ecrt_slave_config_dc(ec_slave_config_t *sc, uint16_t assign_activate,
int ecrt_slave_config_dc(ec_slave_config_t *sc, uint16_t assign_activate,
uint32_t sync0_cycle_time, int32_t sync0_shift_time,
uint32_t sync1_cycle_time, int32_t sync1_shift_time)
{
@ -971,6 +974,7 @@ void ecrt_slave_config_dc(ec_slave_config_t *sc, uint16_t assign_activate,
sc->dc_sync[0].shift_time = sync0_shift_time;
sc->dc_sync[1].cycle_time = sync1_cycle_time;
sc->dc_sync[1].shift_time = sync1_shift_time;
return 0;
}
/****************************************************************************/
@ -1317,7 +1321,7 @@ ec_voe_handler_t *ecrt_slave_config_create_voe_handler(
/****************************************************************************/
void ecrt_slave_config_state(const ec_slave_config_t *sc,
int ecrt_slave_config_state(const ec_slave_config_t *sc,
ec_slave_config_state_t *state)
{
const ec_slave_t *slave = sc->slave;
@ -1331,6 +1335,7 @@ void ecrt_slave_config_state(const ec_slave_config_t *sc,
state->operational = 0;
state->al_state = EC_SLAVE_STATE_UNKNOWN;
}
return 0;
}
/****************************************************************************/

20
master/soe_request.c
View File

@ -223,7 +223,7 @@ int ec_soe_request_append_data(
/** Request a read operation.
*/
void ec_soe_request_read(
int ec_soe_request_read(
ec_soe_request_t *req /**< SoE request. */
)
{
@ -231,13 +231,14 @@ void ec_soe_request_read(
req->state = EC_INT_REQUEST_QUEUED;
req->error_code = 0x0000;
req->jiffies_start = jiffies;
return 0;
}
/****************************************************************************/
/** Request a write operation.
*/
void ec_soe_request_write(
int ec_soe_request_write(
ec_soe_request_t *req /**< SoE request. */
)
{
@ -245,6 +246,7 @@ void ec_soe_request_write(
req->state = EC_INT_REQUEST_QUEUED;
req->error_code = 0x0000;
req->jiffies_start = jiffies;
return 0;
}
/****************************************************************************/
@ -263,18 +265,20 @@ int ec_soe_request_timed_out(const ec_soe_request_t *req /**< SDO request. */)
* Application interface.
****************************************************************************/
void ecrt_soe_request_idn(ec_soe_request_t *req, uint8_t drive_no,
int ecrt_soe_request_idn(ec_soe_request_t *req, uint8_t drive_no,
uint16_t idn)
{
req->drive_no = drive_no;
req->idn = idn;
return 0;
}
/****************************************************************************/
void ecrt_soe_request_timeout(ec_soe_request_t *req, uint32_t timeout)
int ecrt_soe_request_timeout(ec_soe_request_t *req, uint32_t timeout)
{
req->issue_timeout = timeout;
return 0;
}
/****************************************************************************/
@ -300,16 +304,16 @@ ec_request_state_t ecrt_soe_request_state(const ec_soe_request_t *req)
/****************************************************************************/
void ecrt_soe_request_read(ec_soe_request_t *req)
int ecrt_soe_request_read(ec_soe_request_t *req)
{
ec_soe_request_read(req);
return ec_soe_request_read(req);
}
/****************************************************************************/
void ecrt_soe_request_write(ec_soe_request_t *req)
int ecrt_soe_request_write(ec_soe_request_t *req)
{
ec_soe_request_write(req);
return ec_soe_request_write(req);
}
/****************************************************************************/

4
master/soe_request.h
View File

@ -67,8 +67,8 @@ void ec_soe_request_set_idn(ec_soe_request_t *, uint16_t);
int ec_soe_request_alloc(ec_soe_request_t *, size_t);
int ec_soe_request_copy_data(ec_soe_request_t *, const uint8_t *, size_t);
int ec_soe_request_append_data(ec_soe_request_t *, const uint8_t *, size_t);
void ec_soe_request_read(ec_soe_request_t *);
void ec_soe_request_write(ec_soe_request_t *);
int ec_soe_request_read(ec_soe_request_t *);
int ec_soe_request_write(ec_soe_request_t *);
int ec_soe_request_timed_out(const ec_soe_request_t *);
/****************************************************************************/

15
master/voe_handler.c
View File

@ -112,16 +112,17 @@ size_t ec_voe_handler_mem_size(
* Application interface.
****************************************************************************/
void ecrt_voe_handler_send_header(ec_voe_handler_t *voe, uint32_t vendor_id,
int ecrt_voe_handler_send_header(ec_voe_handler_t *voe, uint32_t vendor_id,
uint16_t vendor_type)
{
voe->vendor_id = vendor_id;
voe->vendor_type = vendor_type;
return 0;
}
/****************************************************************************/
void ecrt_voe_handler_received_header(const ec_voe_handler_t *voe,
int ecrt_voe_handler_received_header(const ec_voe_handler_t *voe,
uint32_t *vendor_id, uint16_t *vendor_type)
{
uint8_t *header = voe->datagram.data + EC_MBOX_HEADER_SIZE;
@ -130,6 +131,7 @@ void ecrt_voe_handler_received_header(const ec_voe_handler_t *voe,
*vendor_id = EC_READ_U32(header);
if (vendor_type)
*vendor_type = EC_READ_U16(header + 4);
return 0;
}
/****************************************************************************/
@ -148,30 +150,33 @@ size_t ecrt_voe_handler_data_size(const ec_voe_handler_t *voe)
/****************************************************************************/
void ecrt_voe_handler_read(ec_voe_handler_t *voe)
int ecrt_voe_handler_read(ec_voe_handler_t *voe)
{
voe->dir = EC_DIR_INPUT;
voe->state = ec_voe_handler_state_read_start;
voe->request_state = EC_INT_REQUEST_BUSY;
return 0;
}
/****************************************************************************/
void ecrt_voe_handler_read_nosync(ec_voe_handler_t *voe)
int ecrt_voe_handler_read_nosync(ec_voe_handler_t *voe)
{
voe->dir = EC_DIR_INPUT;
voe->state = ec_voe_handler_state_read_nosync_start;
voe->request_state = EC_INT_REQUEST_BUSY;
return 0;
}
/****************************************************************************/
void ecrt_voe_handler_write(ec_voe_handler_t *voe, size_t size)
int ecrt_voe_handler_write(ec_voe_handler_t *voe, size_t size)
{
voe->dir = EC_DIR_OUTPUT;
voe->data_size = size;
voe->state = ec_voe_handler_state_write_start;
voe->request_state = EC_INT_REQUEST_BUSY;
return 0;
}
/****************************************************************************/