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.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

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

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

/** \file

    31

 * Sercos-over-EtherCAT request functions.

    32

 */

    33

    34

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

    35

    36

#include <linux/module.h>

    37

#include <linux/jiffies.h>

    38

    39

#include "soe_request.h"

    40

    41

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

    42

    43

/** Default timeout in ms to wait for SoE responses.

    44

 */

    45

#define EC_SOE_REQUEST_RESPONSE_TIMEOUT 1000

    46

    47

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

    48

    49

void ec_soe_request_clear_data(ec_soe_request_t *);

    50

    51

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

    52

    53

/** SoE request constructor.

    54

 */

    55

void ec_soe_request_init(

    56

        ec_soe_request_t *req /**< SoE request. */

    57

        )

    58

{

    59

    req->data = NULL;

    60

    req->mem_size = 0;

    61

    req->data_size = 0;

    62

    req->dir = EC_DIR_INVALID;

    63

    req->state = EC_INT_REQUEST_INIT;

    64

    req->jiffies_sent = 0U;

    65

    req->error_code = 0x0000;

    66

}

    67

    68

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

    69

    70

/** SoE request destructor.

    71

 */

    72

void ec_soe_request_clear(

    73

        ec_soe_request_t *req /**< SoE request. */

    74

        )

    75

{

    76

    ec_soe_request_clear_data(req);

    77

}

    78

    79

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

    80

    81

/** Copy another SoE request.

    82

 */

    83

int ec_soe_request_copy(

    84

        ec_soe_request_t *req, /**< SoE request. */

    85

        const ec_soe_request_t *other /**< Other SoE request to copy from. */

    86

        )

    87

{

    88

    req->idn = other->idn;

    89

    return ec_soe_request_copy_data(req, other->data, other->data_size);

    90

}

    91

    92

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

    93

    94

/** Set IDN.

    95

 */

    96

void ec_soe_request_set_idn(

    97

        ec_soe_request_t *req, /**< SoE request. */

    98

        uint16_t idn /** IDN. */

    99

        )

   100

{

   101

    req->idn = idn;

   102

}

   103

   104

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

   105

   106

/** Free allocated memory.

   107

 */

   108

void ec_soe_request_clear_data(

   109

        ec_soe_request_t *req /**< SoE request. */

   110

        )

   111

{

   112

    if (req->data) {

   113

        kfree(req->data);

   114

        req->data = NULL;

   115

    }

   116

   117

    req->mem_size = 0;

   118

    req->data_size = 0;

   119

}

   120

   121

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

   122

   123

/** Pre-allocates the data memory.

   124

 *

   125

 * If the \a mem_size is already bigger than \a size, nothing is done.

   126

 *

   127

 * \return 0 on success, otherwise -ENOMEM.

   128

 */

   129

int ec_soe_request_alloc(

   130

        ec_soe_request_t *req, /**< SoE request. */

   131

        size_t size /**< Data size to allocate. */

   132

        )

   133

{

   134

    if (size <= req->mem_size)

   135

        return 0;

   136

   137

    ec_soe_request_clear_data(req);

   138

   139

    if (!(req->data = (uint8_t *) kmalloc(size, GFP_KERNEL))) {

   140

        EC_ERR("Failed to allocate %zu bytes of SoE memory.\n", size);

   141

        return -ENOMEM;

   142

    }

   143

   144

    req->mem_size = size;

   145

    req->data_size = 0;

   146

    return 0;

   147

}

   148

   149

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

   150

   151

/** Copies SoE data from an external source.

   152

 *

   153

 * If the \a mem_size is to small, new memory is allocated.

   154

 *

   155

 * \retval  0 Success.

   156

 * \retval <0 Error code.

   157

 */

   158

int ec_soe_request_copy_data(

   159

        ec_soe_request_t *req, /**< SoE request. */

   160

        const uint8_t *source, /**< Source data. */

   161

        size_t size /**< Number of bytes in \a source. */

   162

        )

   163

{

   164

    int ret = ec_soe_request_alloc(req, size);

   165

    if (ret < 0)

   166

        return ret;

   167

   168

    memcpy(req->data, source, size);

   169

    req->data_size = size;

   170

    return 0;

   171

}

   172

   173

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

   174

   175

/** Copies SoE data from an external source.

   176

 *

   177

 * If the \a mem_size is to small, new memory is allocated.

   178

 *

   179

 * \retval  0 Success.

   180

 * \retval <0 Error code.

   181

 */

   182

int ec_soe_request_append_data(

   183

        ec_soe_request_t *req, /**< SoE request. */

   184

        const uint8_t *source, /**< Source data. */

   185

        size_t size /**< Number of bytes in \a source. */

   186

        )

   187

{

   188

    if (req->data_size + size > req->mem_size) {

   189

        size_t new_size = req->mem_size ? req->mem_size * 2 : size;

   190

        uint8_t *new_data = (uint8_t *) kmalloc(new_size, GFP_KERNEL);

   191

        if (!new_data) {

   192

            EC_ERR("Failed to allocate %zu bytes of SoE memory.\n",

   193

                    new_size);

   194

            return -ENOMEM;

   195

        }

   196

        memcpy(new_data, req->data, req->data_size);

   197

        kfree(req->data);

   198

        req->data = new_data;

   199

        req->mem_size = new_size;

   200

    }

   201

   202

    memcpy(req->data + req->data_size, source, size);

   203

    req->data_size += size;

   204

    return 0;

   205

}

   206

   207

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

   208

   214

{

   215

    req->dir = EC_DIR_INPUT;

   216

    req->state = EC_INT_REQUEST_QUEUED;

   217

    req->error_code = 0x0000;

   218

}

   219

   220

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

   221

   227

{

   228

    req->dir = EC_DIR_OUTPUT;

   229

    req->state = EC_INT_REQUEST_QUEUED;

   230

    req->error_code = 0x0000;

   231

}

   232

   233

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