1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2008  Olav Zarges, imc Messsysteme GmbH

     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

 * File-over-EtherCAT request functions.

    32

 */

    33

    34

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

    35

    36

#include <linux/module.h>

    37

#include <linux/jiffies.h>

    38

#include <linux/slab.h>

    39

    40

#include "foe_request.h"

    41

#include "foe.h"

    42

    43

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

    44

    45

/** Default timeout in ms to wait for FoE transfer responses.

    46

 */

    47

#define EC_FOE_REQUEST_RESPONSE_TIMEOUT 3000

    48

    49

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

    50

    51

void ec_foe_request_clear_data(ec_foe_request_t *);

    52

    53

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

    54

    55

/** FoE request constructor.

    56

 */

    57

void ec_foe_request_init(

    58

        ec_foe_request_t *req, /**< FoE request. */

    59

        uint8_t* file_name /** filename */)

    60

{

    61

    INIT_LIST_HEAD(&req->list);

    62

    req->buffer = NULL;

    63

    req->file_name = file_name;

    64

    req->buffer_size = 0;

    65

    req->data_size = 0;

    66

    req->dir = EC_DIR_INVALID;

    67

    req->issue_timeout = 0; // no timeout

    68

    req->response_timeout = EC_FOE_REQUEST_RESPONSE_TIMEOUT;

    69

    req->state = EC_INT_REQUEST_INIT;

    70

    req->result = FOE_BUSY;

    71

    req->error_code = 0x00000000;

    72

}

    73

    74

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

    75

    76

/** FoE request destructor.

    77

 */

    78

void ec_foe_request_clear(

    79

        ec_foe_request_t *req /**< FoE request. */

    80

        )

    81

{

    82

    ec_foe_request_clear_data(req);

    83

}

    84

    85

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

    86

    87

/** FoE request destructor.

    88

 */

    89

void ec_foe_request_clear_data(

    90

        ec_foe_request_t *req /**< FoE request. */

    91

        )

    92

{

    93

    if (req->buffer) {

    94

        kfree(req->buffer);

    95

        req->buffer = NULL;

    96

    }

    97

    98

    req->buffer_size = 0;

    99

    req->data_size = 0;

   100

}

   101

   102

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

   103

   104

/** Pre-allocates the data memory.

   105

 *

   106

 * If the internal \a buffer_size is already bigger than \a size, nothing is

   107

 * done.

   108

 *

   109

 * \return Zero on success, otherwise a negative error code.

   110

 */

   111

int ec_foe_request_alloc(

   112

        ec_foe_request_t *req, /**< FoE request. */

   113

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

   114

        )

   115

{

   116

    if (size <= req->buffer_size) {

   117

        return 0;

   118

    }

   119

   120

    ec_foe_request_clear_data(req);

   121

   122

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

   123

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

   124

        return -ENOMEM;

   125

    }

   126

   127

    req->buffer_size = size;

   128

    req->data_size = 0;

   129

    return 0;

   130

}

   131

   132

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

   133

   134

/** Copies FoE data from an external source.

   135

 *

   136

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

   137

 *

   138

 * \return Zero on success, otherwise a negative error code.

   139

 */

   140

int ec_foe_request_copy_data(

   141

        ec_foe_request_t *req, /**< FoE request. */

   142

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

   143

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

   144

        )

   145

{

   146

    int ret;

   147

   148

    ret = ec_foe_request_alloc(req, size);

   149

    if (ret) {

   150

        return ret;

   151

    }

   152

   153

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

   154

    req->data_size = size;

   155

    return 0;

   156

}

   157

   158

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

   159

   160

/** Checks, if the timeout was exceeded.

   161

 *

   162

 * \return non-zero if the timeout was exceeded, else zero.

   163

 */

   164

int ec_foe_request_timed_out(

   165

        const ec_foe_request_t *req /**< FoE request. */

   166

        )

   167

{

   168

    return req->issue_timeout

   169

        && jiffies - req->jiffies_start > HZ * req->issue_timeout / 1000;

   170

}

   171

   172

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

   173

   174

/** Set the request timeout.

   175

 */

   176

void ec_foe_request_timeout(

   177

        ec_foe_request_t *req, /**< FoE request. */

   178

        uint32_t timeout /**< Timeout in ms. */

   179

        )

   180

{

   181

    req->issue_timeout = timeout;

   182

}

   183

   184

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

   185

   186

/** Returns a pointer to the request's data.

   187

 *

   188

 * \return Data pointer.

   189

 */

   190

uint8_t *ec_foe_request_data(

   191

        ec_foe_request_t *req /**< FoE request. */

   192

        )

   193

{

   194

    return req->buffer;

   195

}

   196

   197

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

   198

   199

/** Returns the data size.

   200

 *

   201

 * \return Data size.

   202

 */

   203

size_t ec_foe_request_data_size(

   204

        const ec_foe_request_t *req /**< FoE request. */

   205

        )

   206

{

   207

    return req->data_size;

   208

}

   209

   210

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

   211

   212

/** Prepares a read request (slave to master).

   213

 */

   214

void ec_foe_request_read(

   215

        ec_foe_request_t *req /**< FoE request. */

   216

        )

   217

{

   218

    req->dir = EC_DIR_INPUT;

   219

    req->state = EC_INT_REQUEST_QUEUED;

   220

    req->result = FOE_BUSY;

   221

    req->jiffies_start = jiffies;

   222

}

   223

   224

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

   225

   226

/** Prepares a write request (master to slave).

   227

 */

   228

void ec_foe_request_write(

   229

        ec_foe_request_t *req /**< FoE request. */

   230

        )

   231

{

   232

    req->dir = EC_DIR_OUTPUT;

   233

    req->state = EC_INT_REQUEST_QUEUED;

   234

    req->result = FOE_BUSY;

   235

    req->jiffies_start = jiffies;

   236

}

   237

   238

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