1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

     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

/**

    35

   \file

    36

   Canopen-over-EtherCAT Sdo request functions.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

    43

#include "sdo_request.h"

    44

    45

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

    46

    47

void ec_sdo_request_clear_data(ec_sdo_request_t *);

    48

    49

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

    50

    51

/** Sdo request constructor.

    52

 */

    53

void ec_sdo_request_init(

    54

        ec_sdo_request_t *req /**< Sdo request. */

    55

        )

    56

{

    57

    req->data = NULL;

    58

    req->mem_size = 0;

    59

    req->data_size = 0;

    61

    req->state = EC_REQUEST_COMPLETE;

    62

}

    63

    64

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

    65

    66

/** Sdo request destructor.

    67

 */

    68

void ec_sdo_request_clear(

    69

        ec_sdo_request_t *req /**< Sdo request. */

    70

        )

    71

{

    72

    ec_sdo_request_clear_data(req);

    73

}

    74

    75

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

    76

    77

/** Sdo request destructor.

    78

 */

    79

void ec_sdo_request_clear_data(

    80

        ec_sdo_request_t *req /**< Sdo request. */

    81

        )

    82

{

    83

    if (req->data) {

    84

        kfree(req->data);

    85

        req->data = NULL;

    86

    }

    87

    88

    req->mem_size = 0;

    89

    req->data_size = 0;

    90

}

    91

    92

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

    93

    94

/** Set the Sdo address.

    95

 */

    96

void ec_sdo_request_address(

    97

        ec_sdo_request_t *req, /**< Sdo request. */

    98

        uint16_t index, /**< Sdo index. */

    99

        uint8_t subindex /**< Sdo subindex. */

   100

        )

   101

{

   102

    req->index = index;

   103

    req->subindex = subindex;

   104

}

   105

   106

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

   107

   108

/** Pre-allocates the data memory.

   109

 *

   110

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

   111

 */

   112

int ec_sdo_request_alloc(

   113

        ec_sdo_request_t *req, /**< Sdo request. */

   114

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

   115

        )

   116

{

   117

    if (size <= req->mem_size)

   118

        return 0;

   119

   120

    ec_sdo_request_clear_data(req);

   121

   122

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

   123

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

   124

        return -1;

   125

    }

   126

   127

    req->mem_size = size;

   128

    req->data_size = 0;

   129

    return 0;

   130

}

   131

   132

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

   133

   134

/** Copies Sdo data from an external source.

   135

 *

   136

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

   137

 */

   138

int ec_sdo_request_copy_data(

   139

        ec_sdo_request_t *req, /**< Sdo request. */

   140

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

   141

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

   142

        )

   143

{

   144

    if (ec_sdo_request_alloc(req, size))

   145

        return -1;

   146

   147

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

   148

    req->data_size = size;

   149

    return 0;

   150

}

   151

   152

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

   153

 * Realtime interface.

   154

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

   155

   156

void ecrt_sdo_request_timeout(ec_sdo_request_t *req, uint32_t timeout)

   157

{

   158

}

   159

   160

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

   161

   162

uint8_t *ecrt_sdo_request_data(ec_sdo_request_t *req)

   163

{

   164

    return req->data;

   165

}

   166

   167

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

   168

   169

ec_request_state_t ecrt_sdo_request_state(const ec_sdo_request_t *req)

   170

{

   171

    return req->state;

   172

}

   173

   174

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

   175

   176

ec_sdo_request_error_t ecrt_sdo_request_error(const ec_sdo_request_t *req)

   177

{

   178

    return EC_SDO_REQUEST_SUCCESS; // FIXME

   179

}

   180

   181

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

   182

   183

void ecrt_sdo_request_read(ec_sdo_request_t *req)

   184

{

   186

    req->state = EC_REQUEST_QUEUED;

   187

}

   188

   189

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

   190

   191

void ecrt_sdo_request_write(ec_sdo_request_t *req)

   192

{

   194

    req->state = EC_REQUEST_QUEUED;

   195

}

   196

   197

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

   198

   199

EXPORT_SYMBOL(ecrt_sdo_request_timeout);

   200

EXPORT_SYMBOL(ecrt_sdo_request_data);

   201

EXPORT_SYMBOL(ecrt_sdo_request_state);

   202

EXPORT_SYMBOL(ecrt_sdo_request_error);

   203

EXPORT_SYMBOL(ecrt_sdo_request_read);

   204

EXPORT_SYMBOL(ecrt_sdo_request_write);