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

/** \file

    35

 * Canopen-over-EtherCAT Sdo request functions.

    36

 */

    37

    38

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

    39

    40

#include <linux/module.h>

    41

    42

#include "sdo_request.h"

    43

    44

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

    45

    46

void ec_sdo_request_clear_data(ec_sdo_request_t *);

    47

    48

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

    49

    50

/** State type translation table.

    51

 */

    52

static const ec_sdo_request_state_t state_translation_table[] = {

    53

    EC_SDO_REQUEST_UNUSED,  // EC_REQUEST_INIT,

    54

    EC_SDO_REQUEST_BUSY,    // EC_REQUEST_QUEUED,

    55

    EC_SDO_REQUEST_BUSY,    // EC_REQUEST_BUSY,

    56

    EC_SDO_REQUEST_SUCCESS, // EC_REQUEST_SUCCESS,

    57

    EC_SDO_REQUEST_ERROR    // EC_REQUEST_FAILURE

    58

};

    59

    60

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

    61

    62

/** Sdo request constructor.

    63

 */

    64

void ec_sdo_request_init(

    65

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

    66

        )

    67

{

    68

    req->data = NULL;

    69

    req->mem_size = 0;

    70

    req->data_size = 0;

    71

    req->dir = EC_DIR_OUTPUT;

    72

    req->state = EC_REQUEST_INIT;

    73

}

    74

    75

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

    76

    77

/** Sdo request destructor.

    78

 */

    79

void ec_sdo_request_clear(

    80

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

    81

        )

    82

{

    83

    ec_sdo_request_clear_data(req);

    84

}

    85

    86

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

    87

    88

/** Sdo request destructor.

    89

 */

    90

void ec_sdo_request_clear_data(

    91

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

    92

        )

    93

{

    94

    if (req->data) {

    95

        kfree(req->data);

    96

        req->data = NULL;

    97

    }

    98

    99

    req->mem_size = 0;

   100

    req->data_size = 0;

   101

}

   102

   103

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

   104

   105

/** Set the Sdo address.

   106

 */

   107

void ec_sdo_request_address(

   108

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

   109

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

   110

        uint8_t subindex /**< Sdo subindex. */

   111

        )

   112

{

   113

    req->index = index;

   114

    req->subindex = subindex;

   115

}

   116

   117

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

   118

   119

/** Pre-allocates the data memory.

   120

 *

   121

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

   122

 */

   123

int ec_sdo_request_alloc(

   124

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

   125

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

   126

        )

   127

{

   128

    if (size <= req->mem_size)

   129

        return 0;

   130

   131

    ec_sdo_request_clear_data(req);

   132

   133

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

   134

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

   135

        return -1;

   136

    }

   137

   138

    req->mem_size = size;

   139

    req->data_size = 0;

   140

    return 0;

   141

}

   142

   143

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

   144

   145

/** Copies Sdo data from an external source.

   146

 *

   147

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

   148

 */

   149

int ec_sdo_request_copy_data(

   150

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

   151

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

   152

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

   153

        )

   154

{

   155

    if (ec_sdo_request_alloc(req, size))

   156

        return -1;

   157

   158

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

   159

    req->data_size = size;

   160

    return 0;

   161

}

   162

   163

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

   164

 * Realtime interface.

   165

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

   166

   167

void ecrt_sdo_request_timeout(ec_sdo_request_t *req, uint32_t timeout)

   168

{

   169

}

   170

   171

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

   172

   173

uint8_t *ecrt_sdo_request_data(ec_sdo_request_t *req)

   174

{

   175

    return req->data;

   176

}

   177

   178

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

   179

   180

size_t ecrt_sdo_request_data_size(const ec_sdo_request_t *req)

   181

{

   182

    return req->data_size;

   183

}

   184

   185

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

   186

   187

ec_sdo_request_state_t ecrt_sdo_request_state(const ec_sdo_request_t *req)

   188

{

   189

   return state_translation_table[req->state];

   190

}

   191

   192

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

   193

   194

void ecrt_sdo_request_read(ec_sdo_request_t *req)

   195

{

   196

    req->dir = EC_DIR_INPUT;

   197

    req->state = EC_REQUEST_QUEUED;

   198

}

   199

   200

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

   201

   202

void ecrt_sdo_request_write(ec_sdo_request_t *req)

   203

{

   204

    req->dir = EC_DIR_OUTPUT;

   205

    req->state = EC_REQUEST_QUEUED;

   206

}

   207

   208

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

   209

   210

/** \cond */

   211

   212

EXPORT_SYMBOL(ecrt_sdo_request_timeout);

   213

EXPORT_SYMBOL(ecrt_sdo_request_data);

   214

EXPORT_SYMBOL(ecrt_sdo_request_data_size);

   215

EXPORT_SYMBOL(ecrt_sdo_request_state);

   216

EXPORT_SYMBOL(ecrt_sdo_request_read);

   217

EXPORT_SYMBOL(ecrt_sdo_request_write);

   218

   219

/** \endcond */

   220

   221

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