1

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

     2

 *

     3

 *  e c _ c o m m a n d . c

     4

 *

     5

 *  Methoden für ein EtherCAT-Kommando.

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include <linux/slab.h>

    12

    13

#include "ec_command.h"

    14

    15

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

    16

    17

/**

    18

   Kommando-Konstruktor.

    19

    20

   Initialisiert alle Variablen innerhalb des Kommandos auf die

    21

   Default-Werte.

    22

    23

   @param cmd Zeiger auf das zu initialisierende Kommando.

    24

*/

    25

    26

void EtherCAT_command_init(EtherCAT_command_t *cmd)

    27

{

    28

  cmd->type = ECAT_CMD_NONE;

    29

  cmd->address.logical = 0x00000000;

    30

  cmd->data_length = 0;

    31

  cmd->state = ECAT_CS_READY;

    32

  cmd->index = 0;

    33

  cmd->working_counter = 0;

    34

}

    35

    36

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

    37

    38

/**

    39

   Kommando-Destruktor.

    40

    41

   Setzt alle Attribute auf den Anfangswert zurueck.

    42

    43

   @param cmd Zeiger auf das zu initialisierende Kommando.

    44

*/

    45

    46

void EtherCAT_command_clear(EtherCAT_command_t *cmd)

    47

{

    48

  EtherCAT_command_init(cmd);

    49

}

    50

    51

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

    52

    53

#define ECAT_FUNC_HEADER \

    54

  EtherCAT_command_init(cmd)

    55

    56

#define ECAT_FUNC_WRITE_FOOTER \

    57

  cmd->data_length = length; \

    58

  memcpy(cmd->data, data, length);

    59

    60

#define ECAT_FUNC_READ_FOOTER \

    61

  cmd->data_length = length;

    62

    63

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

    64

    65

/**

    66

   Initialisiert ein EtherCAT-NPRD-Kommando.

    67

    68

   @param cmd Zeiger auf das Kommando

    69

   @param node_address Adresse des Knotens (Slaves)

    70

   @param offset Physikalische Speicheradresse im Slave

    71

   @param length Länge der zu lesenden Daten

    72

*/

    73

    74

void EtherCAT_command_read(EtherCAT_command_t *cmd,

    75

                           unsigned short node_address,

    76

                           unsigned short offset,

    77

                           unsigned int length)

    78

{

    79

  if (unlikely(node_address == 0x0000))

    80

    printk(KERN_WARNING "EtherCAT: Warning - Using node address 0x0000!\n");

    81

    82

  ECAT_FUNC_HEADER;

    83

    84

  cmd->type = ECAT_CMD_NPRD;

    85

  cmd->address.phy.dev.node = node_address;

    86

  cmd->address.phy.mem = offset;

    87

    88

  ECAT_FUNC_READ_FOOTER;

    89

}

    90

    91

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

    92

    93

/**

    94

   Initialisiert ein EtherCAT-NPWR-Kommando.

    95

    96

   Alloziert ein "node-adressed physical write"-Kommando

    97

   und fügt es in die Liste des Masters ein.

    98

    99

   @param cmd Zeiger auf das Kommando

   100

   @param node_address Adresse des Knotens (Slaves)

   101

   @param offset Physikalische Speicheradresse im Slave

   102

   @param length Länge der zu schreibenden Daten

   103

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   104

*/

   105

   106

void EtherCAT_command_write(EtherCAT_command_t *cmd,

   107

                            unsigned short node_address,

   108

                            unsigned short offset,

   109

                            unsigned int length,

   110

                            const unsigned char *data)

   111

{

   112

  if (unlikely(node_address == 0x0000))

   113

    printk(KERN_WARNING "EtherCAT: Warning - Using node address 0x0000!\n");

   114

   115

  ECAT_FUNC_HEADER;

   116

   117

  cmd->type = ECAT_CMD_NPWR;

   118

  cmd->address.phy.dev.node = node_address;

   119

  cmd->address.phy.mem = offset;

   120

   121

  ECAT_FUNC_WRITE_FOOTER;

   122

}

   123

   124

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

   125

   126

/**

   127

   Initialisiert ein EtherCAT-APRD-Kommando.

   128

   129

   Alloziert ein "autoincerement physical read"-Kommando

   130

   und fügt es in die Liste des Masters ein.

   131

   132

   @param cmd Zeiger auf das Kommando

   133

   @param ring_position (Negative) Position des Slaves im Bus

   134

   @param offset Physikalische Speicheradresse im Slave

   135

   @param length Länge der zu lesenden Daten

   136

*/

   137

   138

void EtherCAT_command_position_read(EtherCAT_command_t *cmd,

   139

                                    short ring_position,

   140

                                    unsigned short offset,

   141

                                    unsigned int length)

   142

{

   143

  ECAT_FUNC_HEADER;

   144

   145

  cmd->type = ECAT_CMD_APRD;

   146

  cmd->address.phy.dev.pos = ring_position;

   147

  cmd->address.phy.mem = offset;

   148

   149

  ECAT_FUNC_READ_FOOTER;

   150

}

   151

   152

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

   153

   154

/**

   155

   Initialisiert ein EtherCAT-APWR-Kommando.

   156

   157

   Alloziert ein "autoincrement physical write"-Kommando

   158

   und fügt es in die Liste des Masters ein.

   159

   160

   @param cmd Zeiger auf das Kommando

   161

   @param ring_position (Negative) Position des Slaves im Bus

   162

   @param offset Physikalische Speicheradresse im Slave

   163

   @param length Länge der zu schreibenden Daten

   164

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   165

*/

   166

   167

void EtherCAT_command_position_write(EtherCAT_command_t *cmd,

   168

                                     short ring_position,

   169

                                     unsigned short offset,

   170

                                     unsigned int length,

   171

                                     const unsigned char *data)

   172

{

   173

  ECAT_FUNC_HEADER;

   174

   175

  cmd->type = ECAT_CMD_APWR;

   176

  cmd->address.phy.dev.pos = ring_position;

   177

  cmd->address.phy.mem = offset;

   178

   179

  ECAT_FUNC_WRITE_FOOTER;

   180

}

   181

   182

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

   183

   184

/**

   185

   Initialisiert ein EtherCAT-BRD-Kommando.

   186

   187

   Alloziert ein "broadcast read"-Kommando

   188

   und fügt es in die Liste des Masters ein.

   189

   190

   @param cmd Zeiger auf das Kommando

   191

   @param offset Physikalische Speicheradresse im Slave

   192

   @param length Länge der zu lesenden Daten

   193

*/

   194

   195

void EtherCAT_command_broadcast_read(EtherCAT_command_t *cmd,

   196

                                     unsigned short offset,

   197

                                     unsigned int length)

   198

{

   199

  ECAT_FUNC_HEADER;

   200

   201

  cmd->type = ECAT_CMD_BRD;

   202

  cmd->address.phy.dev.node = 0x0000;

   203

  cmd->address.phy.mem = offset;

   204

   205

  ECAT_FUNC_READ_FOOTER;

   206

}

   207

   208

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

   209

   210

/**

   211

   Initialisiert ein EtherCAT-BWR-Kommando.

   212

   213

   Alloziert ein "broadcast write"-Kommando

   214

   und fügt es in die Liste des Masters ein.

   215

   216

   @param cmd Zeiger auf das Kommando

   217

   @param offset Physikalische Speicheradresse im Slave

   218

   @param length Länge der zu schreibenden Daten

   219

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   220

*/

   221

   222

void EtherCAT_command_broadcast_write(EtherCAT_command_t *cmd,

   223

                                      unsigned short offset,

   224

                                      unsigned int length,

   225

                                      const unsigned char *data)

   226

{

   227

  ECAT_FUNC_HEADER;

   228

   229

  cmd->type = ECAT_CMD_BWR;

   230

  cmd->address.phy.dev.node = 0x0000;

   231

  cmd->address.phy.mem = offset;

   232

   233

  ECAT_FUNC_WRITE_FOOTER;

   234

}

   235

   236

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

   237

   238

/**

   239

   Initialisiert ein EtherCAT-LRW-Kommando.

   240

   241

   Alloziert ein "logical read write"-Kommando

   242

   und fügt es in die Liste des Masters ein.

   243

   244

   @param cmd Zeiger auf das Kommando

   245

   @param offset Logische Speicheradresse

   246

   @param length Länge der zu lesenden/schreibenden Daten

   247

   @param data Zeiger auf Speicher mit zu lesenden/schreibenden Daten

   248

*/

   249

   250

void EtherCAT_command_logical_read_write(EtherCAT_command_t *cmd,

   251

                                         unsigned int offset,

   252

                                         unsigned int length,

   253

                                         unsigned char *data)

   254

{

   255

  ECAT_FUNC_HEADER;

   256

   257

  cmd->type = ECAT_CMD_LRW;

   258

  cmd->address.logical = offset;

   259

   260

  ECAT_FUNC_WRITE_FOOTER;

   261

}

   262

   263

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