1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  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 and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

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

    14

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

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

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

    19

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

    20

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

    21

 *

    22

 *  Using the EtherCAT technology and brand is permitted in compliance with

    23

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    24

 *

    25

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

    26

    27

/**

    28

   \file

    29

   Methods of an EtherCAT datagram.

    30

*/

    31

    32

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

    33

    34

#include <linux/slab.h>

    35

    36

#include "datagram.h"

    37

#include "master.h"

    38

    39

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

    40

    41

/** \cond */

    42

    43

#define EC_FUNC_HEADER \

    44

    ret = ec_datagram_prealloc(datagram, data_size); \

    45

    if (unlikely(ret)) \

    46

        return ret; \

    47

    datagram->index = 0; \

    48

    datagram->working_counter = 0; \

    49

    datagram->state = EC_DATAGRAM_INIT;

    50

    51

#define EC_FUNC_FOOTER \

    52

    datagram->data_size = data_size; \

    53

    return 0;

    54

    55

/** \endcond */

    56

    57

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

    58

    59

/** Array of datagram type strings used in ec_datagram_type_string().

    60

 *

    61

 * \attention This is indexed by ec_datagram_type_t.

    62

 */

    63

static const char *type_strings[] = {

    64

    "?",

    65

    "APRD",

    66

    "APWR",

    67

    "APRW",

    68

    "FPRD",

    69

    "FPWR",

    70

    "FPRW",

    71

    "BRD",

    72

    "BWR",

    73

    "BRW",

    74

    "LRD",

    75

    "LWR",

    76

    "LRW",

    77

    "ARMW",

    78

    "FRMW"

    79

};

    80

    81

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

    82

    83

/** Constructor.

    84

 */

    85

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

    86

{

    87

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

    88

    datagram->type = EC_DATAGRAM_NONE;

    89

    memset(datagram->address, 0x00, EC_ADDR_LEN);

    90

    datagram->data = NULL;

    91

    datagram->data_origin = EC_ORIG_INTERNAL;

    92

    datagram->mem_size = 0;

    93

    datagram->data_size = 0;

    94

    datagram->index = 0x00;

    95

    datagram->working_counter = 0x0000;

    96

    datagram->state = EC_DATAGRAM_INIT;

    97

#ifdef EC_HAVE_CYCLES

    98

    datagram->cycles_sent = 0;

    99

#endif

   100

    datagram->jiffies_sent = 0;

   101

#ifdef EC_HAVE_CYCLES

   102

    datagram->cycles_received = 0;

   103

#endif

   104

    datagram->jiffies_received = 0;

   105

    datagram->skip_count = 0;

   106

    datagram->stats_output_jiffies = 0;

   107

    memset(datagram->name, 0x00, EC_DATAGRAM_NAME_SIZE);

   108

}

   109

   110

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

   111

   112

/** Destructor.

   113

 */

   114

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

   115

{

   116

    if (datagram->data_origin == EC_ORIG_INTERNAL && datagram->data)

   117

        kfree(datagram->data);

   118

}

   119

   120

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

   121

   122

/** Allocates internal payload memory.

   123

 *

   124

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

   125

 *

   126

 * \attention If external payload memory has been provided, no range checking

   127

 *            is done!

   128

 *

   129

 * \return 0 in case of success, otherwise \a -ENOMEM.

   130

 */

   131

int ec_datagram_prealloc(

   132

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   133

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

   134

        )

   135

{

   136

    if (datagram->data_origin == EC_ORIG_EXTERNAL

   137

            || size <= datagram->mem_size)

   138

        return 0;

   139

   140

    if (datagram->data) {

   141

        kfree(datagram->data);

   142

        datagram->data = NULL;

   143

        datagram->mem_size = 0;

   144

    }

   145

   146

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

   147

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

   148

        return -ENOMEM;

   149

    }

   150

   151

    datagram->mem_size = size;

   152

    return 0;

   153

}

   154

   155

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

   156

   157

/** Fills the datagram payload memory with zeros.

   158

 */

   159

void ec_datagram_zero(ec_datagram_t *datagram /**< EtherCAT datagram. */)

   160

{

   161

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

   162

}

   163

   164

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

   165

   166

/** Initializes an EtherCAT APRD datagram.

   167

 *

   168

 * \return Return value of ec_datagram_prealloc().

   169

 */

   170

int ec_datagram_aprd(

   171

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   172

        uint16_t ring_position, /**< Auto-increment address. */

   173

        uint16_t mem_address, /**< Physical memory address. */

   174

        size_t data_size /**< Number of bytes to read. */

   175

        )

   176

{

   177

    int ret;

   178

    EC_FUNC_HEADER;

   179

    datagram->type = EC_DATAGRAM_APRD;

   180

    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));

   181

    EC_WRITE_U16(datagram->address + 2, mem_address);

   182

    EC_FUNC_FOOTER;

   183

}

   184

   185

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

   186

   187

/** Initializes an EtherCAT APWR datagram.

   188

 *

   189

 * \return Return value of ec_datagram_prealloc().

   190

 */

   191

int ec_datagram_apwr(

   192

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   193

        uint16_t ring_position, /**< Auto-increment address. */

   194

        uint16_t mem_address, /**< Physical memory address. */

   195

        size_t data_size /**< Number of bytes to write. */

   196

        )

   197

{

   198

    int ret;

   199

    EC_FUNC_HEADER;

   200

    datagram->type = EC_DATAGRAM_APWR;

   201

    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));

   202

    EC_WRITE_U16(datagram->address + 2, mem_address);

   203

    EC_FUNC_FOOTER;

   204

}

   205

   206

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

   207

   208

/** Initializes an EtherCAT APRW datagram.

   209

 *

   210

 * \return Return value of ec_datagram_prealloc().

   211

 */

   212

int ec_datagram_aprw(

   213

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   214

        uint16_t ring_position, /**< Auto-increment address. */

   215

        uint16_t mem_address, /**< Physical memory address. */

   216

        size_t data_size /**< Number of bytes to write. */

   217

        )

   218

{

   219

    int ret;

   220

    EC_FUNC_HEADER;

   221

    datagram->type = EC_DATAGRAM_APRW;

   222

    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));

   223

    EC_WRITE_U16(datagram->address + 2, mem_address);

   224

    EC_FUNC_FOOTER;

   225

}

   226

   227

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

   228

   229

/** Initializes an EtherCAT ARMW datagram.

   230

 *

   231

 * \return Return value of ec_datagram_prealloc().

   232

 */

   233

int ec_datagram_armw(

   234

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   235

        uint16_t ring_position, /**< Auto-increment address. */

   236

        uint16_t mem_address, /**< Physical memory address. */

   237

        size_t data_size /**< Number of bytes to read. */

   238

        )

   239

{

   240

    int ret;

   241

    EC_FUNC_HEADER;

   242

    datagram->type = EC_DATAGRAM_ARMW;

   243

    EC_WRITE_S16(datagram->address, (int16_t) ring_position * (-1));

   244

    EC_WRITE_U16(datagram->address + 2, mem_address);

   245

    EC_FUNC_FOOTER;

   246

}

   247

   248

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

   249

   250

/** Initializes an EtherCAT FPRD datagram.

   251

 *

   252

 * \return Return value of ec_datagram_prealloc().

   253

 */

   254

int ec_datagram_fprd(

   255

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   256

        uint16_t configured_address, /**< Configured station address. */

   257

        uint16_t mem_address, /**< Physical memory address. */

   258

        size_t data_size /**< Number of bytes to read. */

   259

        )

   260

{

   261

    int ret;

   262

   263

    if (unlikely(configured_address == 0x0000))

   264

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

   265

   266

    EC_FUNC_HEADER;

   267

    datagram->type = EC_DATAGRAM_FPRD;

   268

    EC_WRITE_U16(datagram->address, configured_address);

   269

    EC_WRITE_U16(datagram->address + 2, mem_address);

   270

    EC_FUNC_FOOTER;

   271

}

   272

   273

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

   274

   275

/** Initializes an EtherCAT FPWR datagram.

   276

 *

   277

 * \return Return value of ec_datagram_prealloc().

   278

 */

   279

int ec_datagram_fpwr(

   280

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   281

        uint16_t configured_address, /**< Configured station address. */

   282

        uint16_t mem_address, /**< Physical memory address. */

   283

        size_t data_size /**< Number of bytes to write. */

   284

        )

   285

{

   286

    int ret;

   287

   288

    if (unlikely(configured_address == 0x0000))

   289

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

   290

   291

    EC_FUNC_HEADER;

   292

    datagram->type = EC_DATAGRAM_FPWR;

   293

    EC_WRITE_U16(datagram->address, configured_address);

   294

    EC_WRITE_U16(datagram->address + 2, mem_address);

   295

    EC_FUNC_FOOTER;

   296

}

   297

   298

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

   299

   300

/** Initializes an EtherCAT FPRW datagram.

   301

 *

   302

 * \return Return value of ec_datagram_prealloc().

   303

 */

   304

int ec_datagram_fprw(

   305

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   306

        uint16_t configured_address, /**< Configured station address. */

   307

        uint16_t mem_address, /**< Physical memory address. */

   308

        size_t data_size /**< Number of bytes to write. */

   309

        )

   310

{

   311

    int ret;

   312

   313

    if (unlikely(configured_address == 0x0000))

   314

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

   315

   316

    EC_FUNC_HEADER;

   317

    datagram->type = EC_DATAGRAM_FPRW;

   318

    EC_WRITE_U16(datagram->address, configured_address);

   319

    EC_WRITE_U16(datagram->address + 2, mem_address);

   320

    EC_FUNC_FOOTER;

   321

}

   322

   323

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

   324

   325

/** Initializes an EtherCAT FRMW datagram.

   326

 *

   327

 * \return Return value of ec_datagram_prealloc().

   328

 */

   329

int ec_datagram_frmw(

   330

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   331

        uint16_t configured_address, /**< Configured station address. */

   332

        uint16_t mem_address, /**< Physical memory address. */

   333

        size_t data_size /**< Number of bytes to write. */

   334

        )

   335

{

   336

    int ret;

   337

   338

    if (unlikely(configured_address == 0x0000))

   339

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

   340

   341

    EC_FUNC_HEADER;

   342

    datagram->type = EC_DATAGRAM_FRMW;

   343

    EC_WRITE_U16(datagram->address, configured_address);

   344

    EC_WRITE_U16(datagram->address + 2, mem_address);

   345

    EC_FUNC_FOOTER;

   346

}

   347

   348

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

   349

   350

/** Initializes an EtherCAT BRD datagram.

   351

 *

   352

 * \return Return value of ec_datagram_prealloc().

   353

 */

   354

int ec_datagram_brd(

   355

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   356

        uint16_t mem_address, /**< Physical memory address. */

   357

        size_t data_size /**< Number of bytes to read. */

   358

        )

   359

{

   360

    int ret;

   361

    EC_FUNC_HEADER;

   362

    datagram->type = EC_DATAGRAM_BRD;

   363

    EC_WRITE_U16(datagram->address, 0x0000);

   364

    EC_WRITE_U16(datagram->address + 2, mem_address);

   365

    EC_FUNC_FOOTER;

   366

}

   367

   368

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

   369

   370

/** Initializes an EtherCAT BWR datagram.

   371

 *

   372

 * \return Return value of ec_datagram_prealloc().

   373

 */

   374

int ec_datagram_bwr(

   375

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   376

        uint16_t mem_address, /**< Physical memory address. */

   377

        size_t data_size /**< Number of bytes to write. */

   378

        )

   379

{

   380

    int ret;

   381

    EC_FUNC_HEADER;

   382

    datagram->type = EC_DATAGRAM_BWR;

   383

    EC_WRITE_U16(datagram->address, 0x0000);

   384

    EC_WRITE_U16(datagram->address + 2, mem_address);

   385

    EC_FUNC_FOOTER;

   386

}

   387

   388

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

   389

   390

/** Initializes an EtherCAT BRW datagram.

   391

 *

   392

 * \return Return value of ec_datagram_prealloc().

   393

 */

   394

int ec_datagram_brw(

   395

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   396

        uint16_t mem_address, /**< Physical memory address. */

   397

        size_t data_size /**< Number of bytes to write. */

   398

        )

   399

{

   400

    int ret;

   401

    EC_FUNC_HEADER;

   402

    datagram->type = EC_DATAGRAM_BRW;

   403

    EC_WRITE_U16(datagram->address, 0x0000);

   404

    EC_WRITE_U16(datagram->address + 2, mem_address);

   405

    EC_FUNC_FOOTER;

   406

}

   407

   408

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

   409

   410

/** Initializes an EtherCAT LRD datagram.

   411

 *

   412

 * \attention It is assumed, that the external memory is at least \a data_size

   413

 *            bytes large.

   414

 *

   415

 * \return Return value of ec_datagram_prealloc().

   416

 */

   417

int ec_datagram_lrd(

   418

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   419

        uint32_t offset, /**< Logical address. */

   420

        size_t data_size, /**< Number of bytes to read/write. */

   421

        uint8_t *external_memory /**< Pointer to the memory to use. */

   422

        )

   423

{

   424

    int ret;

   425

    datagram->data = external_memory;

   426

    datagram->data_origin = EC_ORIG_EXTERNAL;

   427

    EC_FUNC_HEADER;

   428

    datagram->type = EC_DATAGRAM_LRD;

   429

    EC_WRITE_U32(datagram->address, offset);

   430

    EC_FUNC_FOOTER;

   431

}

   432

   433

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

   434

   435

/** Initializes an EtherCAT LWR datagram.

   436

 *

   437

 * \attention It is assumed, that the external memory is at least \a data_size

   438

 *            bytes large.

   439

 *

   440

 * \return Return value of ec_datagram_prealloc().

   441

 */

   442

int ec_datagram_lwr(

   443

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   444

        uint32_t offset, /**< Logical address. */

   445

        size_t data_size, /**< Number of bytes to read/write. */

   446

        uint8_t *external_memory /**< Pointer to the memory to use. */

   447

        )

   448

{

   449

    int ret;

   450

    datagram->data = external_memory;

   451

    datagram->data_origin = EC_ORIG_EXTERNAL;

   452

    EC_FUNC_HEADER;

   453

    datagram->type = EC_DATAGRAM_LWR;

   454

    EC_WRITE_U32(datagram->address, offset);

   455

    EC_FUNC_FOOTER;

   456

}

   457

   458

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

   459

   460

/** Initializes an EtherCAT LRW datagram.

   461

 *

   462

 * \attention It is assumed, that the external memory is at least \a data_size

   463

 *            bytes large.

   464

 *

   465

 * \return Return value of ec_datagram_prealloc().

   466

 */

   467

int ec_datagram_lrw(

   468

        ec_datagram_t *datagram, /**< EtherCAT datagram. */

   469

        uint32_t offset, /**< Logical address. */

   470

        size_t data_size, /**< Number of bytes to read/write. */

   471

        uint8_t *external_memory /**< Pointer to the memory to use. */

   472

        )

   473

{

   474

    int ret;

   475

    datagram->data = external_memory;

   476

    datagram->data_origin = EC_ORIG_EXTERNAL;

   477

    EC_FUNC_HEADER;

   478

    datagram->type = EC_DATAGRAM_LRW;

   479

    EC_WRITE_U32(datagram->address, offset);

   480

    EC_FUNC_FOOTER;

   481

}

   482

   483

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

   484

   485

/** Evaluates the working counter of a single-cast datagram.

   486

 *

   487

 * Outputs an error message.

   488

 */