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

 *

    36

 * EtherCAT master application interface.

    37

 *

    38

 * \defgroup ApplicationInterface EtherCAT Application Interface

    39

 *

    40

 * EtherCAT interface for realtime applications. This interface is designed

    41

 * for realtime modules that want to use EtherCAT. There are functions to

    42

 * request a master, to map process data, to communicate with slaves via CoE

    43

 * and to configure and activate the bus.

    44

 *

    45

 * Changes in version 1.5:

    46

 *

    47

 * - Changed the return value of ecrt_request_master().

    48

 *

    49

 * Changes in Version 1.4:

    50

 *

    51

 * - Replaced ec_slave_t with ec_slave_config_t, separating the bus

    52

 *   configuration from the actual slaves. Therefore, renamed

    53

 *   ecrt_master_get_slave() to ecrt_master_slave_config().

    54

 * - Replaced slave address string with alias and position values. See

    55

 *   ecrt_master_slave_config().

    56

 * - Removed ecrt_master_get_slave_by_pos(), because it is no longer

    57

 *   necessary due to alias/position addressing.

    58

 * - Added ec_slave_config_state_t for the new method

    59

 *   ecrt_slave_config_state().

    60

 * - Process data memory for a domain can now be allocated externally. This

    61

 *   offers the possibility to use a shared-memory region. Therefore,

    62

 *   added the domain methods ecrt_domain_size() and

    63

 *   ecrt_domain_external_memory().

    64

 * - Pdo entry registration functions do not return a process data pointer,

    65

 *   but an offset in the domain's process data. In addition, an optional bit

    66

 *   position can be requested. This was necessary for the external domain

    67

 *   memory. An additional advantage is, that the returned offset is

    68

 *   immediately valid. If the domain's process data is allocated internally,

    69

 *   the start address can be retrieved with ecrt_domain_data().

    70

 * - Replaced ecrt_slave_pdo_mapping/add/clear() with

    71

 *   ecrt_slave_config_pdo_assign_add() to add a Pdo to a sync manager's Pdo

    72

 *   assignment and ecrt_slave_config_pdo_mapping_add() to add a Pdo entry to a

    73

 *   Pdo's mapping. ecrt_slave_config_pdos() is a convenience function

    74

 *   for both, that uses the new data types ec_pdo_info_t and

    75

 *   ec_pdo_entry_info_t. Pdo entries, that are mapped with these functions

    76

 *   can now immediately be registered, even if the bus is offline.

    77

 * - Renamed ec_bus_status_t, ec_master_status_t to ec_bus_state_t and

    78

 *   ec_master_state_t, respectively. Renamed ecrt_master_get_status() to

    79

 *   ecrt_master_state(), for consistency reasons.

    80

 * - Added ec_domain_state_t and #ec_wc_state_t for a new output parameter

    81

 *   of ecrt_domain_state(). The domain state object does now contain

    82

 *   information, if the process data was exchanged completely.

    83

 * - Former "Pdo registration" meant Pdo entry registration in fact, therefore

    84

 *   renamed ec_pdo_reg_t to ec_pdo_entry_reg_t and ecrt_domain_register_pdo()

    85

 *   to ecrt_slave_config_reg_pdo_entry().

    86

 * - Removed ecrt_domain_register_pdo_range(), because it's functionality can

    87

 *   be reached by specifying an explicit Pdo assignment/mapping and

    88

 *   registering the mapped Pdo entries.

    89

 * - Added an Sdo access interface, working with Sdo requests. These can be

    90

 *   scheduled for reading and writing during realtime operation.

    91

 * - Exported ecrt_slave_config_sdo(), the generic Sdo configuration function.

    92

 * - Removed the bus_state and bus_tainted flags from ec_master_state_t.

    93

 *

    94

 * @{

    95

 */

    96

    97

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

    98

    99

#ifndef __ECRT_H__

   100

#define __ECRT_H__

   101

   102

#ifdef __KERNEL__

   103

#include <asm/byteorder.h>

   104

#include <linux/types.h>

   105

#else

   106

#include <stdlib.h> // for size_t

   107

#include <stdint.h>

   108

#endif

   109

   110

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

   111

 * Global definitions

   112

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

   113

   114

/** EtherCAT realtime interface major version number.

   115

 */

   116

#define ECRT_VER_MAJOR 1

   117

   118

/** EtherCAT realtime interface minor version number.

   119

 */

   120

#define ECRT_VER_MINOR 5

   121

   122

/** EtherCAT realtime interface version word generator.

   123

 */

   124

#define ECRT_VERSION(a, b) (((a) << 8) + (b))

   125

   126

/** EtherCAT realtime interface version word.

   127

 */

   128

#define ECRT_VERSION_MAGIC ECRT_VERSION(ECRT_VER_MAJOR, ECRT_VER_MINOR)

   129

   130

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

   131

   132

/** End of list marker.

   133

 *

   134

 * This can be used with ecrt_slave_config_pdos().

   135

 */

   136

#define EC_END ~0U

   137

   138

/** Maximum number of sync managers per slave.

   139

 */

   140

#define EC_MAX_SYNC_MANAGERS 16

   141

   142

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

   143

 * Data types 

   144

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

   145

   146

struct ec_master;

   147

typedef struct ec_master ec_master_t; /**< \see ec_master */

   148

   149

struct ec_slave_config;

   150

typedef struct ec_slave_config ec_slave_config_t; /**< \see ec_slave_config */

   151

   152

struct ec_domain;

   153

typedef struct ec_domain ec_domain_t; /**< \see ec_domain */

   154

   155

struct ec_sdo_request;

   156

typedef struct ec_sdo_request ec_sdo_request_t; /**< \see ec_sdo_request. */

   157

   158

struct ec_voe_handler;

   159

typedef struct ec_voe_handler ec_voe_handler_t; /**< \see ec_voe_handler. */

   160

   161

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

   162

   163

/** Master state.

   164

 *

   165

 * This is used for the output parameter of ecrt_master_state().

   166

 *

   167

 * \see ecrt_master_state().

   168

 */

   169

typedef struct {

   170

    unsigned int slaves_responding; /**< Number of slaves in the bus. */

   171

    unsigned int al_states : 4; /**< Application-layer states of all slaves.

   172

                                  The states are coded in the lower 4 bits.

   173

                                  If a bit is set, it means that at least one

   174

                                  slave in the bus is in the corresponding

   175

                                  state:

   176

                                  - Bit 0: \a INIT

   177

                                  - Bit 1: \a PREOP

   178

                                  - Bit 2: \a SAFEOP

   179

                                  - Bit 3: \a OP */

   180

    unsigned int link_up : 1; /**< \a true, if the network link is up. */

   181

} ec_master_state_t;

   182

   183

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

   184

   185

/** Slave configuration state.

   186

 *

   187

 * This is used as an output parameter of ecrt_slave_config_state().

   188

 * 

   189

 * \see ecrt_slave_config_state().

   190

 */

   191

typedef struct  {

   192

    unsigned int online : 1; /**< The slave is online. */

   193

    unsigned int operational : 1; /**< The slave was brought into \a OP state

   194

                                    using the specified configuration. */

   195

    unsigned int al_state : 4; /**< The application-layer state of the slave.

   196

                                 - 1: \a INIT

   197

                                 - 2: \a PREOP

   198

                                 - 4: \a SAFEOP

   199

                                 - 8: \a OP

   200

   201

                                 Note that each state is coded in a different

   202

                                 bit! */

   203

} ec_slave_config_state_t;

   204

   205

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

   206

   207

/** Domain working counter interpretation.

   208

 *

   209

 * This is used in ec_domain_state_t.

   210

 */

   211

typedef enum {

   212

    EC_WC_ZERO = 0,   /**< No registered process data were exchanged. */

   213

    EC_WC_INCOMPLETE, /**< Some of the registered process data were

   214

                        exchanged. */

   215

    EC_WC_COMPLETE    /**< All registered process data were exchanged. */

   216

} ec_wc_state_t;

   217

   218

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

   219

   220

/** Domain state.

   221

 *

   222

 * This is used for the output parameter of ecrt_domain_state().

   223

 */

   224

typedef struct {

   225

    unsigned int working_counter; /**< Value of the last working counter. */

   226

    ec_wc_state_t wc_state; /**< Working counter interpretation. */

   227

} ec_domain_state_t;

   228

   229

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

   230

   231

/** Direction type for Pdo assignment functions.

   232

 */

   233

typedef enum {

   234

    EC_DIR_INVALID, /**< Invalid direction. Do not use this value. */

   235

    EC_DIR_OUTPUT, /**< Values written by the master. */

   236

    EC_DIR_INPUT, /**< Values read by the master. */

   237

    EC_DIR_COUNT /**< Number of directions. For internal use only. */

   238

} ec_direction_t;

   239

   240

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

   241

   242

/** Pdo entry configuration information.

   243

 *

   244

 * This is the data type of the \a entries field in ec_pdo_info_t.

   245

 *

   246

 * \see ecrt_slave_config_pdos().

   247

 */

   248

typedef struct {

   249

    uint16_t index; /**< Pdo entry index. */

   250

    uint8_t subindex; /**< Pdo entry subindex. */

   251

    uint8_t bit_length; /**< Size of the Pdo entry in bit. */

   252

} ec_pdo_entry_info_t;

   253

   254

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

   255

   256

/** Pdo configuration information.

   257

 * 

   258

 * This is the data type of the \a pdos field in ec_sync_info_t.

   259

 * 

   260

 * \see ecrt_slave_config_pdos().

   261

 */

   262

typedef struct {

   263

    uint16_t index; /**< Pdo index. */

   264

    unsigned int n_entries; /**< Number of Pdo entries in \a entries to map.

   265

                              Zero means, that the default mapping shall be

   266

                              used (this can only be done if the slave is

   267

                              present at bus configuration time). */

   268

    ec_pdo_entry_info_t *entries; /**< Array of Pdo entries to map. Can either

   269

                                    be \a NULL, or must contain at

   270

                                    least \a n_entries values. */

   271

} ec_pdo_info_t;

   272

   273

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

   274

   275

/** Sync manager configuration information.

   276

 *

   277

 * This can be use to configure multiple sync managers including the Pdo

   278

 * assignment and Pdo mapping. It is used as an input parameter type in

   279

 * ecrt_slave_config_pdos().

   280

 */

   281

typedef struct {

   282

    uint8_t index; /**< Sync manager index. Must be less

   283

                     than #EC_MAX_SYNC_MANAGERS for a valid sync manager,

   284

                     but can also be \a 0xff to mark the end of the list. */

   285

    ec_direction_t dir; /**< Sync manager direction. */

   286

    unsigned int n_pdos; /**< Number of Pdos in \a pdos. */

   287

    ec_pdo_info_t *pdos; /**< Array with Pdos to assign. This must contain

   288

                            at least \a n_pdos Pdos. */

   289

} ec_sync_info_t;

   290

   291

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

   292

   293

/** List record type for Pdo entry mass-registration.

   294

 *

   295

 * This type is used for the array parameter of the

   296

 * ecrt_domain_reg_pdo_entry_list()

   297

 */

   298

typedef struct {

   299

    uint16_t alias; /**< Slave alias address. */

   300

    uint16_t position; /**< Slave position. */

   301

    uint32_t vendor_id; /**< Slave vendor ID. */

   302

    uint32_t product_code; /**< Slave product code. */

   303

    uint16_t index; /**< Pdo entry index. */

   304

    uint8_t subindex; /**< Pdo entry subindex. */

   305

    unsigned int *offset; /**< Pointer to a variable to store the Pdo entry's

   306

                       (byte-)offset in the process data. */

   307

    unsigned int *bit_position; /**< Pointer to a variable to store a bit 

   308

                                  position (0-7) within the \a offset. Can be

   309

                                  NULL, in which case an error is raised if the

   310

                                  Pdo entry does not byte-align. */

   311

} ec_pdo_entry_reg_t;

   312

   313

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

   314

   315

/** Request state.

   316

 *

   317

 * This is used as return type for ecrt_sdo_request_state() and

   318

 * ecrt_voe_handler_state().

   319

 */

   320

typedef enum {

   321

    EC_REQUEST_UNUSED, /**< Not requested. */

   322

    EC_REQUEST_BUSY, /**< Request is being processed. */

   323

    EC_REQUEST_SUCCESS, /**< Request was processed successfully. */

   324

    EC_REQUEST_ERROR, /**< Request processing failed. */

   325

} ec_request_state_t;

   326

   327

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

   328

 * Global functions

   329

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

   330

   331

/** Returns the version magic of the realtime interface.

   332

 *

   333

 * \return Value of ECRT_VERSION_MAGIC() at EtherCAT master compile time.

   334

 */

   335

unsigned int ecrt_version_magic(void);

   336

   337

/** Requests an EtherCAT master for realtime operation.

   338

 * 

   339

 * Before an application can access an EtherCAT master, it has to reserve one

   340

 * for exclusive use.

   341

 *

   342

 * This function has to be the first function an application has to call to

   343

 * use EtherCAT. The function takes the index of the master as its argument.

   344

 * The first master has index 0, the n-th master has index n - 1. The number

   345

 * of masters has to be specified when loading the master module.

   346

 *

   347

 * \attention In kernel context, the returned pointer has to be checked for

   348

 * errors using the IS_ERR() macro.

   349

 *

   350

 * \return If \a IS_ERR() returns zero, the result is a pointer to the

   351

 * reserved master, otherwise, the result is an error code.

   352

 */

   353

ec_master_t *ecrt_request_master(

   354

        unsigned int master_index /**< Index of the master to request. */

   355

        );

   356

   357

/** Releases a requested EtherCAT master.

   358

 *

   359

 * After use, a master it has to be released to make it available for other

   360

 * applications.

   361

 */

   362

void ecrt_release_master(

   363

        ec_master_t *master /**< EtherCAT master */

   364

        );

   365

   366

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

   367

 * Master methods

   368

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

   369

   370

#ifdef __KERNEL__

   371

   372

/** Sets the locking callbacks.

   373

 *

   374

 * For concurrent master access, the application has to provide a locking

   375

 * mechanism (see section FIXME in the docs). The method takes two function

   376

 * pointers and a data value as its parameters. The arbitrary \a cb_data value

   377

 * will be passed as argument on every callback. Asynchronous master access

   378

 * (like EoE processing) is only possible if the callbacks have been set.

   379

 *

   380

 * The request_cb function must return zero, to allow another instance

   381

 * (an EoE process for example) to access the master. Non-zero means,

   382

 * that access is currently forbidden.

   383

 */

   384

void ecrt_master_callbacks(

   385

        ec_master_t *master, /**< EtherCAT master */

   386

        int (*request_cb)(void *), /**< Lock request function. */

   387

        void (*release_cb)(void *), /**< Lock release function. */

   388

        void *cb_data /**< Arbitrary user data. */

   389

        );

   390

   391

#endif /* __KERNEL__ */

   392

   393

/** Creates a new process data domain.

   394

 *

   395

 * For process data exchange, at least one process data domain is needed.

   396

 * This method creates a new process data domain and returns a pointer to the

   397

 * new domain object. This object can be used for registering Pdos and

   398

 * exchanging them in cyclic operation.

   399

 *

   400

 * \return Pointer to the new domain on success, else NULL.

   401

 */

   402

ec_domain_t *ecrt_master_create_domain(

   403

        ec_master_t *master /**< EtherCAT master. */

   404

        );

   405

   406

/** Obtains a slave configuration.

   407

 *

   408

 * Creates a slave configuration object for the given \a alias and \a position

   409

 * tuple and returns it. If a configuration with the same \a alias and \a

   410

 * position already exists, it will be re-used. In the latter case, the given

   411

 * vendor ID and product code are compared to the stored ones. On mismatch, an

   412

 * error message is raised and the function returns \a NULL.

   413

 *

   414

 * Slaves are addressed with the \a alias and \a position parameters.

   415

 * - If \a alias is zero, \a position is interpreted as the desired slave's

   416

 *   ring position.

   417

 * - If \a alias is non-zero, it matches a slave with the given alias. In this

   418

 *   case, \a position is interpreted as ring offset, starting from the

   419

 *   aliased slave, so a position of zero means the aliased slave itself and a

   420

 *   positive value matches the n-th slave behind the aliased one.

   421

 *

   422

 * If the slave with the given address is found during the bus configuration,

   423

 * its vendor ID and product code are matched against the given value. On

   424

 * mismatch, the slave is not configured and an error message is raised.

   425

 *

   426

 * If different slave configurations are pointing to the same slave during bus

   427

 * configuration, a warning is raised and only the first configuration is

   428

 * applied.

   429

 *

   430

 * \retval >0 Pointer to the slave configuration structure.

   431

 * \retval NULL in the error case.

   432

 */

   433

ec_slave_config_t *ecrt_master_slave_config(

   434

        ec_master_t *master, /**< EtherCAT master */

   435

        uint16_t alias, /**< Slave alias. */

   436

        uint16_t position, /**< Slave position. */

   437

        uint32_t vendor_id, /**< Expected vendor ID. */

   438

        uint32_t product_code /**< Expected product code. */

   439

        );

   440

   441

/** Finishes the configuration phase and prepares for cyclic operation.

   442

 *

   443

 * This function tells the master that the configuration phase is finished and

   444

 * the realtime operation will begin. The function allocates internal memory

   445

 * for the domains and calculates the logical FMMU addresses for domain

   446

 * members. It tells the master state machine that the bus configuration is

   447

 * now to be applied.

   448

 *

   449

 * \attention After this function has been called, the realtime application is

   450

 * in charge of cyclically calling ecrt_master_send() and

   451

 * ecrt_master_receive() to ensure bus communication. Before calling this

   452

 * function, the master thread is responsible for that, so these functions may

   453

 * not be called!

   454

 *

   455

 * \return 0 in case of success, else < 0

   456

 */

   457

int ecrt_master_activate(

   458

        ec_master_t *master /**< EtherCAT master. */

   459

        );

   460

   461

/** Sends all datagrams in the queue.

   462

 *

   463

 * This method takes all datagrams, that have been queued for transmission,

   464

 * puts them into frames, and passes them to the Ethernet device for sending.

   465

 *

   466

 * Has to be called cyclically by the application after ecrt_master_activate()

   467

 * has returned.

   468

 */

   469

void ecrt_master_send(

   470

        ec_master_t *master /**< EtherCAT master. */

   471

        );

   472

   473

/** Fetches received frames from the hardware and processes the datagrams.

   474

 *

   475

 * Queries the network device for received frames by calling the interrupt

   476

 * service routine. Extracts received datagrams and dispatches the results to

   477

 * the datagram objects in the queue. Received datagrams, and the ones that

   478

 * timed out, will be marked, and dequeued.

   479

 *

   480

 * Has to be called cyclically by the realtime application after

   481

 * ecrt_master_activate() has returned.

   482

 */

   483

void ecrt_master_receive(

   484

        ec_master_t *master /**< EtherCAT master. */

   485

        );

   486

   487

/** Reads the current master state.