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

    req->buffer = NULL;

    62

    req->file_name = file_name;

    63

    req->buffer_size = 0;

    64

    req->data_size = 0;

    65

    req->dir = EC_DIR_INVALID;

    66

    req->issue_timeout = 0; // no timeout

    67

    req->response_timeout = EC_FOE_REQUEST_RESPONSE_TIMEOUT;

    68

    req->state = EC_INT_REQUEST_INIT;

    69

    req->result = FOE_BUSY;

    70

    req->error_code = 0x00000000;

    71

}

    72

    73

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

    74

    75

/** FoE request destructor.

    76

 */

    77

void ec_foe_request_clear(

    78

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

    79

        )

    80

{

    81

    ec_foe_request_clear_data(req);

    82

}

    83

    84

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

    85

    86

/** FoE request destructor.

    87

 */

    88

void ec_foe_request_clear_data(

    89

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

    90

        )

    91

{

    92

    if (req->buffer) {

    93

        kfree(req->buffer);

    94

        req->buffer = NULL;

    95

    }

    96

    97

    req->buffer_size = 0;

    98

    req->data_size = 0;

    99

}

   100

   101

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

   102

   103

/** Pre-allocates the data memory.

   104

 *

   105

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

   106

 */

   107

int ec_foe_request_alloc(

   108

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

   109

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

   110

        )

   111

{

   112

    if (size <= req->buffer_size)

   113

        return 0;

   114

   115

    ec_foe_request_clear_data(req);

   116

   117

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

   118

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

   119

        return -1;

   120

    }

   121

   122

    req->buffer_size = size;

   123

    req->data_size = 0;

   124

    return 0;

   125

}

   126

   127

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

   128

   129

/** Copies FoE data from an external source.

   130

 *

   131

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

   132

 */

   133

int ec_foe_request_copy_data(

   134

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

   135

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

   136

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

   137

        )

   138

{

   139

    if (ec_foe_request_alloc(req, size))

   140

        return -1;

   141

   142

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

   143

    req->data_size = size;

   144

    return 0;

   145

}

   146

   147

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

   148

   149

/** Checks, if the timeout was exceeded.

   150

 *

   151

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

   152

 */

   153

int ec_foe_request_timed_out(

   154

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

   155

        )

   156

{

   157

    return req->issue_timeout

   158

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

   159

}

   160

   161

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

   162

   163

/** Set the request timeout.

   164

 */

   165

void ec_foe_request_timeout(

   166

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

   167

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

   168

        )

   169

{

   170

    req->issue_timeout = timeout;

   171

}

   172

   173

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

   174

   175

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

   176

 *

   177

 * \return Data pointer.

   178

 */

   179

uint8_t *ec_foe_request_data(

   180

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

   181

        )

   182

{

   183

    return req->buffer;

   184

}

   185

   186

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

   187

   188

/** Returns the data size.

   189

 *

   190

 * \return Data size.

   191

 */

   192

size_t ec_foe_request_data_size(

   193

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

   194

        )

   195

{

   196

    return req->data_size;

   197

}

   198

   199

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

   200

   201

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

   202

 */

   203

void ec_foe_request_read(

   204

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

   205

        )

   206

{

   207

    req->dir = EC_DIR_INPUT;

   208

    req->state = EC_INT_REQUEST_QUEUED;

   209

    req->result = FOE_BUSY;

   210

    req->jiffies_start = jiffies;

   211

}

   212

   213

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

   214

   215

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

   216

 */

   217

void ec_foe_request_write(

   218

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

   219

        )

   220

{

   221

    req->dir = EC_DIR_OUTPUT;

   222

    req->state = EC_INT_REQUEST_QUEUED;

   223

    req->result = FOE_BUSY;

   224

    req->jiffies_start = jiffies;

   225

}

   226

   227

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