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

    39

#include "foe_request.h"

    40

#include "foe.h"

    41

    42

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

    43

    44

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

    45

 */

    46

#define EC_FOE_REQUEST_RESPONSE_TIMEOUT 3000

    47

    48

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

    49

    50

void ec_foe_request_clear_data(ec_foe_request_t *);

    51

    52

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

    53

    54

/** FoE request constructor.

    55

 */

    56

void ec_foe_request_init(

    57

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

    58

        uint8_t* file_name /** filename */)

    59

{

    60

    req->buffer = NULL;

    61

    req->file_name = file_name;

    62

    req->buffer_size = 0;

    63

    req->data_size = 0;

    64

    req->dir = EC_DIR_INVALID;

    65

    req->issue_timeout = 0; // no timeout

    66

    req->response_timeout = EC_FOE_REQUEST_RESPONSE_TIMEOUT;

    67

    req->state = EC_INT_REQUEST_INIT;

    68

    req->result = FOE_BUSY;

    69

    req->error_code = 0x00000000;

    70

}

    71

    72

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

    73

    74

/** FoE request destructor.

    75

 */

    76

void ec_foe_request_clear(

    77

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

    78

        )

    79

{

    80

    ec_foe_request_clear_data(req);

    81

}

    82

    83

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

    84

    85

/** FoE request destructor.

    86

 */

    87

void ec_foe_request_clear_data(

    88

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

    89

        )

    90

{

    91

    if (req->buffer) {

    92

        kfree(req->buffer);

    93

        req->buffer = NULL;

    94

    }

    95

    96

    req->buffer_size = 0;

    97

    req->data_size = 0;

    98

}

    99

   100

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

   101

   102

/** Pre-allocates the data memory.

   103

 *

   104

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

   105

 */

   106

int ec_foe_request_alloc(

   107

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

   108

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

   109

        )

   110

{

   111

    if (size <= req->buffer_size)

   112

        return 0;

   113

   114

    ec_foe_request_clear_data(req);

   115

   116

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

   117

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

   118

        return -1;

   119

    }

   120

   121

    req->buffer_size = size;

   122

    req->data_size = 0;

   123

    return 0;

   124

}

   125

   126

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

   127

   128

/** Copies FoE data from an external source.

   129

 *

   130

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

   131

 */

   132

int ec_foe_request_copy_data(

   133

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

   134

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

   135

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

   136

        )

   137

{

   138

    if (ec_foe_request_alloc(req, size))

   139

        return -1;

   140

   141

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

   142

    req->data_size = size;

   143

    return 0;

   144

}

   145

   146

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

   147

   148

/** Checks, if the timeout was exceeded.

   149

 *

   150

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

   151

 */

   152

int ec_foe_request_timed_out(const ec_foe_request_t *req /**< FoE request. */)

   153

{

   154

    return req->issue_timeout

   155

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

   156

}

   157

   158

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

   159

   160

void ec_foe_request_timeout(ec_foe_request_t *req, uint32_t timeout)

   161

{

   162

    req->issue_timeout = timeout;

   163

}

   164

   165

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

   166

   167

uint8_t *ec_foe_request_data(ec_foe_request_t *req)

   168

{

   169

    return req->buffer;

   170

}

   171

   172

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

   173

   174

size_t ec_foe_request_data_size(const ec_foe_request_t *req)

   175

{

   176

    return req->data_size;

   177

}

   178

   179

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

   180

   181

void ec_foe_request_read(ec_foe_request_t *req)

   182

{

   183

    req->dir = EC_DIR_INPUT;

   184

    req->state = EC_INT_REQUEST_QUEUED;

   185

    req->result = FOE_BUSY;

   186

    req->jiffies_start = jiffies;

   187

}

   188

   189

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

   190

   191

void ec_foe_request_write(ec_foe_request_t *req)

   192

{

   193

    req->dir = EC_DIR_OUTPUT;

   194

    req->state = EC_INT_REQUEST_QUEUED;

   195

    req->result = FOE_BUSY;

   196

    req->jiffies_start = jiffies;

   197

}

   198

   199

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