1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2008  Olav Zarges, imc Meßsysteme 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

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

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

    15

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

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

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

    20

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

    21

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

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/** \file

    35

 * File-over-EtherCAT request functions.

    36

 */

    37

    38

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

    39

    40

#include <linux/module.h>

    41

#include <linux/jiffies.h>

    42

    43

#include "foe_request.h"

    44

#include "foe.h"

    45

    46

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

    47

    48

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

    49

 */

    50

#define EC_FOE_REQUEST_RESPONSE_TIMEOUT 3000

    51

    52

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

    53

    54

void ec_foe_request_clear_data(ec_foe_request_t *);

    55

    56

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

    57

    58

/** FoE request constructor.

    59

 */

    60

void ec_foe_request_init(

    61

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

    62

        uint8_t* file_name /** filename */)

    63

{

    64

    req->buffer = NULL;

    65

    req->file_name = file_name;

    66

    req->buffer_size = 0;

    67

    req->data_size = 0;

    68

    req->dir = EC_DIR_INVALID;

    69

    req->issue_timeout = 0; // no timeout

    70

    req->response_timeout = EC_FOE_REQUEST_RESPONSE_TIMEOUT;

    71

    req->state = EC_REQUEST_INIT;

    72

    req->result = FOE_BUSY;

    73

    req->error_code = 0x00000000;

    74

}

    75

    76

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

    77

    78

/** FoE request destructor.

    79

 */

    80

void ec_foe_request_clear(

    81

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

    82

        )

    83

{

    84

    ec_foe_request_clear_data(req);

    85

}

    86

    87

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

    88

    89

/** FoE request destructor.

    90

 */

    91

void ec_foe_request_clear_data(

    92

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

    93

        )

    94

{

    95

    if (req->buffer) {

    96

        kfree(req->buffer);

    97

        req->buffer = NULL;

    98

    }

    99

   100

    req->buffer_size = 0;

   101

    req->data_size = 0;

   102

}

   103

   104

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

   105

   106

/** Pre-allocates the data memory.

   107

 *

   108

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

   109

 */

   110

int ec_foe_request_alloc(

   111

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

   112

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

   113

        )

   114

{

   115

    if (size <= req->buffer_size)

   116

        return 0;

   117

   118

    ec_foe_request_clear_data(req);

   119

   120

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

   121

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

   122

        return -1;

   123

    }

   124

   125

    req->buffer_size = size;

   126

    req->data_size = 0;

   127

    return 0;

   128

}

   129

   130

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

   131

   132

/** Copies FoE data from an external source.

   133

 *

   134

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

   135

 */

   136

int ec_foe_request_copy_data(

   137

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

   138

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

   139

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

   140

        )

   141

{

   142

    if (ec_foe_request_alloc(req, size))

   143

        return -1;

   144

   145

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

   146

    req->data_size = size;

   147

    return 0;

   148

}

   149

   150

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

   151

   152

/** Checks, if the timeout was exceeded.

   153

 *

   154

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

   155

 */

   156

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

   157

{

   158

    return req->issue_timeout

   159

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

   160

}

   161

   162

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

   163

   164

void ec_foe_request_timeout(ec_foe_request_t *req, uint32_t timeout)

   165

{

   166

    req->issue_timeout = timeout;

   167

}

   168

   169

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

   170

   171

uint8_t *ec_foe_request_data(ec_foe_request_t *req)

   172

{

   173

    return req->buffer;

   174

}

   175

   176

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

   177

   178

size_t ec_foe_request_data_size(const ec_foe_request_t *req)

   179

{

   180

    return req->data_size;

   181

}

   182

   183

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

   184

   185

void ec_foe_request_read(ec_foe_request_t *req)

   186

{

   187

    req->dir = EC_DIR_INPUT;

   188

    req->state = EC_REQUEST_QUEUED;

   189

    req->result = FOE_BUSY;

   190

    req->jiffies_start = jiffies;

   191

}

   192

   193

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

   194

   195

void ec_foe_request_write(ec_foe_request_t *req)

   196

{

   197

    req->dir = EC_DIR_OUTPUT;

   198

    req->state = EC_REQUEST_QUEUED;

   199

    req->result = FOE_BUSY;

   200

    req->jiffies_start = jiffies;

   201

}

   202

   203

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