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

    INIT_LIST_HEAD(&datagram->queue); // mark as unqueued

    73

    datagram->type = EC_DATAGRAM_NONE;

    74

    datagram->address.logical = 0x00000000;

    75

    datagram->data = NULL;

    76

    datagram->mem_size = 0;

    77

    datagram->data_size = 0;

    78

    datagram->index = 0x00;

    79

    datagram->working_counter = 0x00;

    80

    datagram->state = EC_DATAGRAM_INIT;

    81

    datagram->cycles_queued = 0;

    82

    datagram->cycles_sent = 0;

    83

    datagram->jiffies_sent = 0;

    84

    datagram->cycles_received = 0;

    85

    datagram->jiffies_received = 0;

    86

}

    87

    88

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

    89

    90

/**

    91

   Datagram destructor.

    92

*/

    93

    94

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

    95

{

    96

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

    97

}

    98

    99

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

   100

   101

/**

   102

   Allocates datagram data memory.

   103

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

   104

   \return 0 in case of success, else < 0

   105

*/

   106

   107

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

   108

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

   109

                         )

   110

{

   111

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

   112

   113

    if (datagram->data) {

   114

        kfree(datagram->data);

   115

        datagram->data = NULL;

   116

        datagram->mem_size = 0;

   117

    }

   118

   119

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

   120

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

   121

        return -1;

   122

    }

   123

   124

    datagram->mem_size = size;

   125

    return 0;

   126

}

   127

   128

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

   129

   130

/**

   131

   Initializes an EtherCAT NPRD datagram.

   132

   Node-adressed physical read.

   133

   \return 0 in case of success, else < 0

   134

*/

   135

   136

int ec_datagram_nprd(ec_datagram_t *datagram,

   137

                     /**< EtherCAT datagram */

   138

                     uint16_t node_address,

   139

                     /**< configured station address */

   140

                     uint16_t offset,

   141

                     /**< physical memory address */

   142

                     size_t data_size

   143

                     /**< number of bytes to read */

   144

                     )

   145

{

   146

    if (unlikely(node_address == 0x0000))

   147

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

   148

   149

    EC_FUNC_HEADER;

   150

    datagram->type = EC_DATAGRAM_NPRD;

   151

    datagram->address.physical.slave = node_address;

   152

    datagram->address.physical.mem = offset;

   153

    EC_FUNC_FOOTER;

   154

}

   155

   156

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

   157

   158

/**

   159

   Initializes an EtherCAT NPWR datagram.

   160

   Node-adressed physical write.

   161

   \return 0 in case of success, else < 0

   162

*/

   163

   164

int ec_datagram_npwr(ec_datagram_t *datagram,

   165

                     /**< EtherCAT datagram */

   166

                     uint16_t node_address,

   167

                     /**< configured station address */

   168

                     uint16_t offset,

   169

                     /**< physical memory address */

   170

                     size_t data_size

   171

                     /**< number of bytes to write */

   172

                     )

   173

{

   174

    if (unlikely(node_address == 0x0000))

   175

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

   176

   177

    EC_FUNC_HEADER;

   178

    datagram->type = EC_DATAGRAM_NPWR;

   179

    datagram->address.physical.slave = node_address;

   180

    datagram->address.physical.mem = offset;

   181

    EC_FUNC_FOOTER;

   182

}

   183

   184

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

   185

   186

/**

   187

   Initializes an EtherCAT APRD datagram.

   188

   Autoincrement physical read.

   189

   \return 0 in case of success, else < 0

   190

*/

   191

   192

int ec_datagram_aprd(ec_datagram_t *datagram,

   193

                     /**< EtherCAT datagram */

   194

                     uint16_t ring_position,

   195

                     /**< auto-increment position */

   196

                     uint16_t offset,

   197

                     /**< physical memory address */

   198

                     size_t data_size

   199

                     /**< number of bytes to read */

   200

                     )

   201

{

   202

    EC_FUNC_HEADER;

   203

    datagram->type = EC_DATAGRAM_APRD;

   204

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

   205

    datagram->address.physical.mem = offset;

   206

    EC_FUNC_FOOTER;

   207

}

   208

   209

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

   210

   211

/**

   212

   Initializes an EtherCAT APWR datagram.

   213

   Autoincrement physical write.

   214

   \return 0 in case of success, else < 0

   215

*/

   216

   217

int ec_datagram_apwr(ec_datagram_t *datagram,

   218

                     /**< EtherCAT datagram */

   219

                     uint16_t ring_position,

   220

                     /**< auto-increment position */

   221

                     uint16_t offset,

   222

                     /**< physical memory address */

   223

                     size_t data_size

   224

                     /**< number of bytes to write */

   225

                     )

   226

{

   227

    EC_FUNC_HEADER;

   228

    datagram->type = EC_DATAGRAM_APWR;

   229

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

   230

    datagram->address.physical.mem = offset;

   231

    EC_FUNC_FOOTER;

   232

}

   233

   234

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

   235

   236

/**

   237

   Initializes an EtherCAT BRD datagram.

   238

   Broadcast read.

   239

   \return 0 in case of success, else < 0

   240

*/

   241

   242

int ec_datagram_brd(ec_datagram_t *datagram,

   243

                    /**< EtherCAT datagram */

   244

                    uint16_t offset,

   245

                    /**< physical memory address */

   246

                    size_t data_size

   247

                    /**< number of bytes to read */

   248

                    )

   249

{

   250

    EC_FUNC_HEADER;

   251

    datagram->type = EC_DATAGRAM_BRD;

   252

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

   253

    datagram->address.physical.mem = offset;

   254

    EC_FUNC_FOOTER;

   255

}

   256

   257

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

   258

   259

/**

   260

   Initializes an EtherCAT BWR datagram.

   261

   Broadcast write.

   262

   \return 0 in case of success, else < 0

   263

*/

   264

   265

int ec_datagram_bwr(ec_datagram_t *datagram,

   266

                    /**< EtherCAT datagram */

   267

                    uint16_t offset,

   268

                    /**< physical memory address */

   269

                    size_t data_size

   270

                    /**< number of bytes to write */

   271

                    )

   272

{

   273

    EC_FUNC_HEADER;

   274

    datagram->type = EC_DATAGRAM_BWR;

   275

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

   276

    datagram->address.physical.mem = offset;

   277

    EC_FUNC_FOOTER;

   278

}

   279

   280

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

   281

   282

/**

   283

   Initializes an EtherCAT LRW datagram.

   284

   Logical read write.

   285

   \return 0 in case of success, else < 0

   286

*/

   287

   288

int ec_datagram_lrw(ec_datagram_t *datagram,

   289

                    /**< EtherCAT datagram */

   290

                    uint32_t offset,

   291

                    /**< logical address */

   292

                    size_t data_size

   293

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

   294

                    )

   295

{

   296

    EC_FUNC_HEADER;

   297

    datagram->type = EC_DATAGRAM_LRW;

   298

    datagram->address.logical = offset;

   299

    EC_FUNC_FOOTER;

   300

}

   301

   302

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