etherlabmaster: comparison lib/master.c

equal deleted inserted replaced

-:6a6dec6fc806
+:58572b4208ba
-/******************************************************************************
+/*****************************************************************************
 *
 *  $Id$
 *
 *  Copyright (C) 2006-2009  Florian Pose, Ingenieurgemeinschaft IgH
 *
 *
 *  The license mentioned above concerns the source code only. Using the
 *  EtherCAT technology and brand is only permitted in compliance with the
 *  industrial property and similar rights of Beckhoff Automation GmbH.
 *
-*****************************************************************************/
+****************************************************************************/
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <stdio.h>
 #include <errno.h>
 #include "master.h"
 #include "domain.h"
 #include "slave_config.h"
 #include "master/ioctl.h"
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_reserve(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_REQUEST, NULL) == -1) {
 fprintf(stderr, "Failed to reserve master: %s\n",
 return -1;
 }
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ec_master_clear_config(ec_master_t *master)
 {
 ec_domain_t *d, *next_d;
 ec_slave_config_t *c, *next_c;
 c = next_c;
 }
 master->first_config = NULL;
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ec_master_clear(ec_master_t *master)
 {
 if (master->process_data)  {
 munmap(master->process_data, master->process_data_size);
 if (master->fd != -1) {
 close(master->fd);
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ec_master_add_domain(ec_master_t *master, ec_domain_t *domain)
 {
 if (master->first_domain) {
 ec_domain_t *d = master->first_domain;
 } else {
 master->first_domain = domain;
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 ec_domain_t *ecrt_master_create_domain(ec_master_t *master)
 {
 ec_domain_t *domain;
 int index;
 ec_master_add_domain(master, domain);
 return domain;
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ec_master_add_slave_config(ec_master_t *master, ec_slave_config_t *sc)
 {
 if (master->first_config) {
 ec_slave_config_t *c = master->first_config;
 } else {
 master->first_config = sc;
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,
 uint16_t alias, uint16_t position, uint32_t vendor_id,
 uint32_t product_code)
 {
 ec_master_add_slave_config(master, sc);
 return sc;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master(ec_master_t* master, ec_master_info_t *master_info)
 {
 ec_ioctl_master_t data;
 master_info->scan_busy = data.scan_busy;
 master_info->app_time = data.app_time;
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,
 ec_slave_info_t *slave_info)
 {
 ec_ioctl_slave_t data;
 slave_info->revision_number = data.revision_number;
 slave_info->serial_number = data.serial_number;
 slave_info->alias = data.alias;
 slave_info->current_on_ebus = data.current_on_ebus;
 for ( i = 0; i < EC_MAX_PORTS; i++ ) {
-	slave_info->ports[i].desc = data.ports[i].desc;
+slave_info->ports[i].desc = data.ports[i].desc;
-	slave_info->ports[i].link.link_up = data.ports[i].link.link_up;
+slave_info->ports[i].link.link_up = data.ports[i].link.link_up;
-	slave_info->ports[i].link.loop_closed = data.ports[i].link.loop_closed;
+slave_info->ports[i].link.loop_closed =
-	slave_info->ports[i].link.signal_detected = data.ports[i].link.signal_detected;
+data.ports[i].link.loop_closed;
-	slave_info->ports[i].receive_time = data.ports[i].receive_time;
+slave_info->ports[i].link.signal_detected =
-	slave_info->ports[i].next_slave = data.ports[i].next_slave;
+data.ports[i].link.signal_detected;
-	slave_info->ports[i].delay_to_next_dc = data.ports[i].delay_to_next_dc;
+slave_info->ports[i].receive_time = data.ports[i].receive_time;
+slave_info->ports[i].next_slave = data.ports[i].next_slave;
+slave_info->ports[i].delay_to_next_dc =
+data.ports[i].delay_to_next_dc;
 }
 slave_info->al_state = data.al_state;
 slave_info->error_flag = data.error_flag;
 slave_info->sync_count = data.sync_count;
 slave_info->sdo_count = data.sdo_count;
 strncpy(slave_info->name, data.name, EC_MAX_STRING_LENGTH);
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_get_sync_manager(ec_master_t *master, uint16_t slave_position,
 uint8_t sync_index, ec_sync_info_t *sync)
 {
 ec_ioctl_slave_sync_t data;
 EC_WD_ENABLE : EC_WD_DISABLE;
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_get_pdo(ec_master_t *master, uint16_t slave_position,
 uint8_t sync_index, uint16_t pos, ec_pdo_info_t *pdo)
 {
 ec_ioctl_slave_sync_pdo_t data;
 pdo->entries = NULL;
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_get_pdo_entry(ec_master_t *master, uint16_t slave_position,
 uint8_t sync_index, uint16_t pdo_pos, uint16_t entry_pos,
 ec_pdo_entry_info_t *entry)
 {
 entry->bit_length = data.bit_length;
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position,
 uint16_t index, uint8_t subindex, uint8_t *data,
 size_t data_size, uint32_t *abort_code)
 {
 }
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_sdo_download_complete(ec_master_t *master,
 uint16_t slave_position, uint16_t index, uint8_t *data,
 size_t data_size, uint32_t *abort_code)
 {
 }
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,
 uint16_t index, uint8_t subindex, uint8_t *target,
 size_t target_size, size_t *result_size, uint32_t *abort_code)
 {
 *result_size = upload.data_size;
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_write_idn(ec_master_t *master, uint16_t slave_position,
 uint8_t drive_no, uint16_t idn, uint8_t *data, size_t data_size,
 uint16_t *error_code)
 {
 }
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position,
 uint8_t drive_no, uint16_t idn, uint8_t *target, size_t target_size,
 size_t *result_size, uint16_t *error_code)
 {
 *result_size = io.data_size;
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_activate(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_ACTIVATE,
 &master->process_data_size) == -1) {
 if (master->process_data_size) {
 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", strerror(errno));
+fprintf(stderr, "Failed to map process data: %s",
+strerror(errno));
 master->process_data = NULL;
 master->process_data_size = 0;
 return -1; // FIXME
 }
 }
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_deactivate(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_DEACTIVATE, NULL) == -1) {
 fprintf(stderr, "Failed to deactivate master: %s\n", strerror(errno));
 }
 ec_master_clear_config(master);
 }
-/*****************************************************************************/
+/****************************************************************************/
-int ecrt_master_set_send_interval(ec_master_t *master,size_t send_interval_us)
+int ecrt_master_set_send_interval(ec_master_t *master,
+size_t send_interval_us)
 {
 if (ioctl(master->fd, EC_IOCTL_SET_SEND_INTERVAL,
 &send_interval_us) == -1) {
 fprintf(stderr, "Failed to set send interval: %s\n",
 strerror(errno));
 return -1; // FIXME
 }
 return 0;
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_send(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_SEND, NULL) == -1) {
 fprintf(stderr, "Failed to send: %s\n", strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_receive(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_RECEIVE, NULL) == -1) {
 fprintf(stderr, "Failed to receive: %s\n", strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)
 {
 if (ioctl(master->fd, EC_IOCTL_MASTER_STATE, state) == -1) {
 fprintf(stderr, "Failed to get master state: %s\n", strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 int ecrt_master_link_state(const ec_master_t *master, unsigned int dev_idx,
 ec_master_link_state_t *state)
 {
 ec_ioctl_link_state_t io;
 fprintf(stderr, "Failed to get link state: %s\n", strerror(errno));
 return -errno;
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)
 {
 ec_ioctl_app_time_t data;
 fprintf(stderr, "Failed to set application time: %s\n",
 strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_sync_reference_clock(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_SYNC_REF, NULL) == -1) {
 fprintf(stderr, "Failed to sync reference clock: %s\n",
 strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_sync_slave_clocks(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_SYNC_SLAVES, NULL) == -1) {
 fprintf(stderr, "Failed to sync slave clocks: %s\n", strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_sync_monitor_queue(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_SYNC_MON_QUEUE, NULL) == -1) {
 fprintf(stderr, "Failed to queue sync monitor datagram: %s\n",
 strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/
 uint32_t ecrt_master_sync_monitor_process(ec_master_t *master)
 {
 uint32_t time_diff;
 }
 return time_diff;
 }
-/*****************************************************************************/
+/****************************************************************************/
 void ecrt_master_reset(ec_master_t *master)
 {
 if (ioctl(master->fd, EC_IOCTL_RESET, NULL) == -1) {
 fprintf(stderr, "Failed to reset master: %s\n", strerror(errno));
 }
 }
-/*****************************************************************************/
+/****************************************************************************/

branch	stable-1.5
changeset 2426	58572b4208ba
parent 2419	fdb85a806585
child 2427	17ada1c77acc