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 \a buffer_size is already bigger than \a size, nothing is done.

   107

 */

   108

int ec_foe_request_alloc(

   109

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

   110

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

   111

        )

   112

{

   113

    if (size <= req->buffer_size) {

   114

        return 0;

   115

    }

   116

   117

    ec_foe_request_clear_data(req);

   118

   119

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

   120

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

   121

        return -ENOMEM;

   122

    }

   123

   124

    req->buffer_size = size;

   125

    req->data_size = 0;

   126

    return 0;

   127

}

   128

   129

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

   130

   131

/** Copies FoE data from an external source.

   132

 *

   133

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

   134

 */

   135

int ec_foe_request_copy_data(

   136

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

   137

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

   138

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

   139

        )

   140

{

   141

    int ret;

   142

   143

    ret = ec_foe_request_alloc(req, size);

   144

    if (ret) {

   145

        return ret;

   146

    }

   147

   148

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

   149

    req->data_size = size;

   150

    return 0;

   151

}

   152

   153

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

   154

   155

/** Checks, if the timeout was exceeded.

   156

 *

   157

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

   158

 */

   159

int ec_foe_request_timed_out(

   160

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

   161

        )

   162

{

   163

    return req->issue_timeout

   164

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

   165

}

   166

   167

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

   168

   169

/** Set the request timeout.

   170

 */

   171

void ec_foe_request_timeout(

   172

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

   173

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

   174

        )

   175

{

   176

    req->issue_timeout = timeout;

   177

}

   178

   179

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

   180

   181

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

   182

 *

   183

 * \return Data pointer.

   184

 */

   185

uint8_t *ec_foe_request_data(

   186

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

   187

        )

   188

{

   189

    return req->buffer;

   190

}

   191

   192

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

   193

   194

/** Returns the data size.

   195

 *

   196

 * \return Data size.

   197

 */

   198

size_t ec_foe_request_data_size(

   199

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

   200

        )

   201

{

   202

    return req->data_size;

   203

}

   204

   205

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

   206

   207

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

   208

 */

   209

void ec_foe_request_read(

   210

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

   211

        )

   212

{

   213

    req->dir = EC_DIR_INPUT;

   214

    req->state = EC_INT_REQUEST_QUEUED;

   215

    req->result = FOE_BUSY;

   216

    req->jiffies_start = jiffies;

   217

}

   218

   219

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

   220

   221

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

   222

 */

   223

void ec_foe_request_write(

   224

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

   225

        )

   226

{

   227

    req->dir = EC_DIR_OUTPUT;

   228

    req->state = EC_INT_REQUEST_QUEUED;

   229

    req->result = FOE_BUSY;

   230

    req->jiffies_start = jiffies;

   231

}

   232

   233

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