1

/******************************************************************************

     2

 *  

     3

 * $Id$

     4

 * 

     5

 * Copyright (C) 2006-2008  Florian Pose, Ingenieurgemeinschaft IgH

     6

 * 

     7

 * This file is part of the IgH EtherCAT master userspace library.

     8

 * 

     9

 * The IgH EtherCAT master userspace library is free software: you can

    10

 * redistribute it and/or modify it under the terms of the GNU Lesser General

    11

 * Public License as published by the Free Software Foundation, version 2 of

    12

 * the License.

    13

 * 

    14

 * The IgH EtherCAT master userspace library is distributed in the hope that

    15

 * it will be useful, but WITHOUT ANY WARRANTY; without even the implied

    16

 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 * GNU Lesser General Public License for more details.

    18

 * 

    19

 * You should have received a copy of the GNU Lesser General Public License

    20

 * along with the IgH EtherCAT master userspace library. If not, see

    21

 * <http://www.gnu.org/licenses/>.

    22

 * 

    23

 * The right to use EtherCAT Technology is granted and comes free of charge

    24

 * under condition of compatibility of product made by Licensee. People

    25

 * intending to distribute/sell products based on the code, have to sign an

    26

 * agreement to guarantee that products using software based on IgH EtherCAT

    27

 * master stay compatible with the actual EtherCAT specification (which are

    28

 * released themselves as an open standard) as the (only) precondition to have

    29

 * the right to use EtherCAT Technology, IP and trade marks.

    30

 *

    31

 *****************************************************************************/

    32

    33

/** \file

    34

 * Vendor-specific-over-EtherCAT protocol handler functions.

    35

 */

    36

    37

/*****************************************************************************/

    38

    39

#include <stdlib.h>

    40

#include <sys/ioctl.h>

    41

#include <stdio.h>

    42

#include <errno.h>

    43

#include <string.h>

    44

    45

#include "voe_handler.h"

    46

#include "slave_config.h"

    47

#include "master.h"

    48

#include "master/ioctl.h"

    49

    50

/*****************************************************************************/

    51

    52

void ecrt_voe_handler_send_header(ec_voe_handler_t *voe, uint32_t vendor_id,

    53

        uint16_t vendor_type)

    54

{

    55

    ec_ioctl_voe_t data;

    56

    57

    data.config_index = voe->config->index;

    58

    data.voe_index = voe->index;

    59

    data.vendor_id = &vendor_id;

    60

    data.vendor_type = &vendor_type;

    61

    62

    if (ioctl(voe->config->master->fd, EC_IOCTL_VOE_SEND_HEADER, &data) == -1)

    63

        fprintf(stderr, "Failed to set VoE send header: %s\n",

    64

                strerror(errno));

    65

}

    66

    67

/*****************************************************************************/

    68

    69

void ecrt_voe_handler_received_header(const ec_voe_handler_t *voe,

    70

        uint32_t *vendor_id, uint16_t *vendor_type)

    71

{

    72

    ec_ioctl_voe_t data;

    73

    74

    data.config_index = voe->config->index;

    75

    data.voe_index = voe->index;

    76

    data.vendor_id = vendor_id;

    77

    data.vendor_type = vendor_type;

    78

    79

    if (ioctl(voe->config->master->fd, EC_IOCTL_VOE_REC_HEADER, &data) == -1)

    80

        fprintf(stderr, "Failed to get received VoE header: %s\n",

    81

                strerror(errno));

    82

}

    83

    84

/*****************************************************************************/

    85

    86

uint8_t *ecrt_voe_handler_data(ec_voe_handler_t *voe)

    87

{

    88

    return voe->data;

    89

}

    90

    91

/*****************************************************************************/

    92

    93

size_t ecrt_voe_handler_data_size(const ec_voe_handler_t *voe)

    94

{

    95

    return voe->data_size;

    96

}

    97

    98

/*****************************************************************************/

    99

   100

void ecrt_voe_handler_read(ec_voe_handler_t *voe)

   101

{

   102

    ec_ioctl_voe_t data;

   103

   104

    data.config_index = voe->config->index;

   105

    data.voe_index = voe->index;

   106

   107

    if (ioctl(voe->config->master->fd, EC_IOCTL_VOE_READ, &data) == -1)

   108

        fprintf(stderr, "Failed to initiate VoE reading: %s\n",

   109

                strerror(errno));

   110

}

   111

   112

/*****************************************************************************/

   113

   114

void ecrt_voe_handler_write(ec_voe_handler_t *voe, size_t size)

   115

{

   116

    ec_ioctl_voe_t data;

   117

   118

    data.config_index = voe->config->index;

   119

    data.voe_index = voe->index;

   120

    data.size = size;

   121

    data.data = voe->data;

   122

   123

    if (ioctl(voe->config->master->fd, EC_IOCTL_VOE_WRITE, &data) == -1)

   124

        fprintf(stderr, "Failed to initiate VoE writing: %s\n",

   125

                strerror(errno));

   126

}

   127

   128

/*****************************************************************************/

   129

   130

ec_request_state_t ecrt_voe_handler_execute(ec_voe_handler_t *voe)

   131

{

   132

    ec_ioctl_voe_t data;

   133

   134

    data.config_index = voe->config->index;

   135

    data.voe_index = voe->index;

   136

    data.size = 0;

   137

   138

    if (ioctl(voe->config->master->fd, EC_IOCTL_VOE_EXEC, &data) == -1) {

   139

        fprintf(stderr, "Failed to execute VoE handler: %s\n",

   140

                strerror(errno));

   141

        return EC_REQUEST_ERROR;

   142

    }

   143

   144

    if (data.size) { // new data waiting to be copied

   145

        if (voe->mem_size < data.size) {

   146

            if (voe->data)

   147

                free(voe->data);

   148

            voe->data = malloc(data.size);

   149

            if (!voe->data) {

   150

                voe->mem_size = 0;

   151

                fprintf(stderr, "Failed to allocate VoE data memory!");

   152

                return EC_REQUEST_ERROR;

   153

            }

   154

            voe->mem_size = data.size;

   155

        }

   156

   157

        data.data = voe->data;

   158

   159

        if (ioctl(voe->config->master->fd, EC_IOCTL_VOE_DATA, &data) == -1) {

   160

            fprintf(stderr, "Failed to get VoE data: %s\n", strerror(errno));

   161

            return EC_REQUEST_ERROR;

   162

        }

   163

        voe->data_size = data.size;

   164

    }

   165

   166

    return data.state;

   167

}

   168

   169

/*****************************************************************************/