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

   Methods of an EtherCAT datagram.

    37

*/

    38

    39

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

    40

    41

#include <linux/slab.h>

    42

    43

#include "datagram.h"

    44

#include "master.h"

    45

    46

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

    47

    48

/** \cond */

    49

    50

#define EC_FUNC_HEADER \

    51

    if (unlikely(ec_datagram_prealloc(datagram, data_size))) \

    52

        return -1; \

    53

    datagram->index = 0; \

    54

    datagram->working_counter = 0; \

    55

    datagram->state = EC_DATAGRAM_INIT;

    56

    57

#define EC_FUNC_FOOTER \

    58

    datagram->data_size = data_size; \

    59

    memset(datagram->data, 0x00, data_size); \

    60

    return 0;

    61

    62

/** \endcond */

    63

    64

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

    65

    66

/**

    67

   Datagram constructor.

    68

*/

    69

    70

void ec_datagram_init(ec_datagram_t *datagram /**< EtherCAT datagram */)

    71

{

    72

    datagram->type = EC_DATAGRAM_NONE;

    73

    datagram->address.logical = 0x00000000;

    74

    datagram->data = NULL;

    75

    datagram->mem_size = 0;

    76

    datagram->data_size = 0;

    77

    datagram->index = 0x00;

    78

    datagram->working_counter = 0x00;

    79

    datagram->state = EC_DATAGRAM_INIT;

    81

    datagram->cycles_sent = 0;

    85

}

    86

    87

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

    88

    89

/**

    90

   Datagram destructor.

    91

*/

    92

    93

void ec_datagram_clear(ec_datagram_t *datagram /**< EtherCAT datagram */)

    94

{

    95

    if (datagram->data) kfree(datagram->data);

    96

}

    97

    98

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

    99

   100

/**

   101

   Allocates datagram data memory.

   102

   If the allocated memory is already larger than requested, nothing ist done.

   103

   \return 0 in case of success, else < 0

   104

*/

   105

   106

int ec_datagram_prealloc(ec_datagram_t *datagram, /**< EtherCAT datagram */

   107

                         size_t size /**< New size in bytes */

   108

                         )

   109

{

   110

    if (size <= datagram->mem_size) return 0;

   111

   112

    if (datagram->data) {

   113

        kfree(datagram->data);

   114

        datagram->data = NULL;

   115

        datagram->mem_size = 0;

   116

    }

   117

   118

    if (!(datagram->data = kmalloc(size, GFP_KERNEL))) {

   119

        EC_ERR("Failed to allocate %i bytes of datagram memory!\n", size);

   120

        return -1;

   121

    }

   122

   123

    datagram->mem_size = size;

   124

    return 0;

   125

}

   126

   127

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

   128

   129

/**

   130

   Initializes an EtherCAT NPRD datagram.

   131

   Node-adressed physical read.

   132

   \return 0 in case of success, else < 0

   133

*/

   134

   135

int ec_datagram_nprd(ec_datagram_t *datagram,

   136

                     /**< EtherCAT datagram */

   137

                     uint16_t node_address,

   138

                     /**< configured station address */

   139

                     uint16_t offset,

   140

                     /**< physical memory address */

   141

                     size_t data_size

   142

                     /**< number of bytes to read */

   143

                     )

   144

{

   145

    if (unlikely(node_address == 0x0000))

   146

        EC_WARN("Using node address 0x0000!\n");

   147

   148

    EC_FUNC_HEADER;

   149

    datagram->type = EC_DATAGRAM_NPRD;

   150

    datagram->address.physical.slave = node_address;

   151

    datagram->address.physical.mem = offset;

   152

    EC_FUNC_FOOTER;

   153

}

   154

   155

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

   156

   157

/**

   158

   Initializes an EtherCAT NPWR datagram.

   159

   Node-adressed physical write.

   160

   \return 0 in case of success, else < 0

   161

*/

   162

   163

int ec_datagram_npwr(ec_datagram_t *datagram,

   164

                     /**< EtherCAT datagram */

   165

                     uint16_t node_address,

   166

                     /**< configured station address */

   167

                     uint16_t offset,

   168

                     /**< physical memory address */

   169

                     size_t data_size

   170

                     /**< number of bytes to write */

   171

                     )

   172

{

   173

    if (unlikely(node_address == 0x0000))

   174

        EC_WARN("Using node address 0x0000!\n");

   175

   176

    EC_FUNC_HEADER;

   177

    datagram->type = EC_DATAGRAM_NPWR;

   178

    datagram->address.physical.slave = node_address;

   179

    datagram->address.physical.mem = offset;

   180

    EC_FUNC_FOOTER;

   181

}

   182

   183

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

   184

   185

/**

   186

   Initializes an EtherCAT APRD datagram.

   187

   Autoincrement physical read.

   188

   \return 0 in case of success, else < 0

   189

*/

   190

   191

int ec_datagram_aprd(ec_datagram_t *datagram,

   192

                     /**< EtherCAT datagram */

   193

                     uint16_t ring_position,

   194

                     /**< auto-increment position */

   195

                     uint16_t offset,

   196

                     /**< physical memory address */

   197

                     size_t data_size

   198

                     /**< number of bytes to read */

   199

                     )

   200

{

   201

    EC_FUNC_HEADER;

   202

    datagram->type = EC_DATAGRAM_APRD;

   203

    datagram->address.physical.slave = (int16_t) ring_position * (-1);

   204

    datagram->address.physical.mem = offset;

   205

    EC_FUNC_FOOTER;

   206

}

   207

   208

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

   209

   210

/**

   211

   Initializes an EtherCAT APWR datagram.

   212

   Autoincrement physical write.

   213

   \return 0 in case of success, else < 0

   214

*/

   215

   216

int ec_datagram_apwr(ec_datagram_t *datagram,

   217

                     /**< EtherCAT datagram */

   218

                     uint16_t ring_position,

   219

                     /**< auto-increment position */

   220

                     uint16_t offset,

   221

                     /**< physical memory address */

   222

                     size_t data_size

   223

                     /**< number of bytes to write */

   224

                     )

   225

{

   226

    EC_FUNC_HEADER;

   227

    datagram->type = EC_DATAGRAM_APWR;

   228

    datagram->address.physical.slave = (int16_t) ring_position * (-1);

   229

    datagram->address.physical.mem = offset;

   230

    EC_FUNC_FOOTER;

   231

}

   232

   233

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

   234

   235

/**

   236

   Initializes an EtherCAT BRD datagram.

   237

   Broadcast read.

   238

   \return 0 in case of success, else < 0

   239

*/

   240

   241

int ec_datagram_brd(ec_datagram_t *datagram,

   242

                    /**< EtherCAT datagram */

   243

                    uint16_t offset,

   244

                    /**< physical memory address */

   245

                    size_t data_size

   246

                    /**< number of bytes to read */

   247

                    )

   248

{

   249

    EC_FUNC_HEADER;

   250

    datagram->type = EC_DATAGRAM_BRD;

   251

    datagram->address.physical.slave = 0x0000;

   252

    datagram->address.physical.mem = offset;

   253

    EC_FUNC_FOOTER;

   254

}

   255

   256

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

   257

   258

/**

   259

   Initializes an EtherCAT BWR datagram.

   260

   Broadcast write.

   261

   \return 0 in case of success, else < 0

   262

*/

   263

   264

int ec_datagram_bwr(ec_datagram_t *datagram,

   265

                    /**< EtherCAT datagram */

   266

                    uint16_t offset,

   267

                    /**< physical memory address */

   268

                    size_t data_size

   269

                    /**< number of bytes to write */

   270

                    )

   271

{

   272

    EC_FUNC_HEADER;

   273

    datagram->type = EC_DATAGRAM_BWR;

   274

    datagram->address.physical.slave = 0x0000;

   275

    datagram->address.physical.mem = offset;

   276

    EC_FUNC_FOOTER;

   277

}

   278

   279

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

   280

   281

/**

   282

   Initializes an EtherCAT LRW datagram.

   283

   Logical read write.

   284

   \return 0 in case of success, else < 0

   285

*/

   286

   287

int ec_datagram_lrw(ec_datagram_t *datagram,

   288

                    /**< EtherCAT datagram */

   289

                    uint32_t offset,

   290

                    /**< logical address */

   291

                    size_t data_size

   292

                    /**< number of bytes to read/write */

   293

                    )

   294

{

   295

    EC_FUNC_HEADER;

   296

    datagram->type = EC_DATAGRAM_LRW;

   297

    datagram->address.logical = offset;

   298

    EC_FUNC_FOOTER;

   299

}

   300

   301

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