1

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

     2

 *

     3

 *  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 "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 ec_command_init(ec_command_t *cmd)

    27

{

    28

  cmd->type = EC_COMMAND_NONE;

    29

  cmd->address.logical = 0x00000000;

    30

  cmd->data_length = 0;

    31

  cmd->state = EC_COMMAND_STATE_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 ec_command_clear(ec_command_t *cmd)

    47

{

    48

  ec_command_init(cmd);

    49

}

    50

    51

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

    52

    53

#define EC_FUNC_HEADER \

    54

  ec_command_init(cmd)

    55

    56

#define EC_FUNC_WRITE_FOOTER \

    57

  cmd->data_length = length; \

    58

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

    59

    60

#define EC_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 ec_command_read(ec_command_t *cmd, unsigned short node_address,

    75

                     unsigned short offset, unsigned int length)

    76

{

    77

  if (unlikely(node_address == 0x0000))

    78

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

    79

    80

  EC_FUNC_HEADER;

    81

    82

  cmd->type = EC_COMMAND_NPRD;

    83

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

    84

  cmd->address.phy.mem = offset;

    85

    86

  EC_FUNC_READ_FOOTER;

    87

}

    88

    89

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

    90

    91

/**

    92

   Initialisiert ein EtherCAT-NPWR-Kommando.

    93

    94

   Alloziert ein "node-adressed physical write"-Kommando

    95

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

    96

    97

   @param cmd Zeiger auf das Kommando

    98

   @param node_address Adresse des Knotens (Slaves)

    99

   @param offset Physikalische Speicheradresse im Slave

   100

   @param length Länge der zu schreibenden Daten

   101

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   102

*/

   103

   104

void ec_command_write(ec_command_t *cmd, unsigned short node_address,

   105

                      unsigned short offset, unsigned int length,

   106

                      const unsigned char *data)

   107

{

   108

  if (unlikely(node_address == 0x0000))

   109

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

   110

   111

  EC_FUNC_HEADER;

   112

   113

  cmd->type = EC_COMMAND_NPWR;

   114

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

   115

  cmd->address.phy.mem = offset;

   116

   117

  EC_FUNC_WRITE_FOOTER;

   118

}

   119

   120

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

   121

   122

/**

   123

   Initialisiert ein EtherCAT-APRD-Kommando.

   124

   125

   Alloziert ein "autoincerement physical read"-Kommando

   126

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

   127

   128

   @param cmd Zeiger auf das Kommando

   129

   @param ring_position (Negative) Position des Slaves im Bus

   130

   @param offset Physikalische Speicheradresse im Slave

   131

   @param length Länge der zu lesenden Daten

   132

*/

   133

   134

void ec_command_position_read(ec_command_t *cmd, short ring_position,

   135

                              unsigned short offset, unsigned int length)

   136

{

   137

  EC_FUNC_HEADER;

   138

   139

  cmd->type = EC_COMMAND_APRD;

   140

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

   141

  cmd->address.phy.mem = offset;

   142

   143

  EC_FUNC_READ_FOOTER;

   144

}

   145

   146

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

   147

   148

/**

   149

   Initialisiert ein EtherCAT-APWR-Kommando.

   150

   151

   Alloziert ein "autoincrement physical write"-Kommando

   152

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

   153

   154

   @param cmd Zeiger auf das Kommando

   155

   @param ring_position (Negative) Position des Slaves im Bus

   156

   @param offset Physikalische Speicheradresse im Slave

   157

   @param length Länge der zu schreibenden Daten

   158

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   159

*/

   160

   161

void ec_command_position_write(ec_command_t *cmd, short ring_position,

   162

                               unsigned short offset, unsigned int length,

   163

                               const unsigned char *data)

   164

{

   165

  EC_FUNC_HEADER;

   166

   167

  cmd->type = EC_COMMAND_APWR;

   168

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

   169

  cmd->address.phy.mem = offset;

   170

   171

  EC_FUNC_WRITE_FOOTER;

   172

}

   173

   174

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

   175

   176

/**

   177

   Initialisiert ein EtherCAT-BRD-Kommando.

   178

   179

   Alloziert ein "broadcast read"-Kommando

   180

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

   181

   182

   @param cmd Zeiger auf das Kommando

   183

   @param offset Physikalische Speicheradresse im Slave

   184

   @param length Länge der zu lesenden Daten

   185

*/

   186

   187

void ec_command_broadcast_read(ec_command_t *cmd, unsigned short offset,

   188

                               unsigned int length)

   189

{

   190

  EC_FUNC_HEADER;

   191

   192

  cmd->type = EC_COMMAND_BRD;

   193

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

   194

  cmd->address.phy.mem = offset;

   195

   196

  EC_FUNC_READ_FOOTER;

   197

}

   198

   199

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

   200

   201

/**

   202

   Initialisiert ein EtherCAT-BWR-Kommando.

   203

   204

   Alloziert ein "broadcast write"-Kommando

   205

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

   206

   207

   @param cmd Zeiger auf das Kommando

   208

   @param offset Physikalische Speicheradresse im Slave

   209

   @param length Länge der zu schreibenden Daten

   210

   @param data Zeiger auf Speicher mit zu schreibenden Daten

   211

*/

   212

   213

void ec_command_broadcast_write(ec_command_t *cmd, unsigned short offset,

   214

                                unsigned int length, const unsigned char *data)

   215

{

   216

  EC_FUNC_HEADER;

   217

   218

  cmd->type = EC_COMMAND_BWR;

   219

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

   220

  cmd->address.phy.mem = offset;

   221

   222

  EC_FUNC_WRITE_FOOTER;

   223

}

   224

   225

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

   226

   227

/**

   228

   Initialisiert ein EtherCAT-LRW-Kommando.

   229

   230

   Alloziert ein "logical read write"-Kommando

   231

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

   232

   233

   @param cmd Zeiger auf das Kommando

   234

   @param offset Logische Speicheradresse

   235

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

   236

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

   237

*/

   238

   239

void ec_command_logical_read_write(ec_command_t *cmd, unsigned int offset,

   240

                                   unsigned int length, unsigned char *data)

   241

{

   242

  EC_FUNC_HEADER;

   243

   244

  cmd->type = EC_COMMAND_LRW;

   245

  cmd->address.logical = offset;

   246

   247

  EC_FUNC_WRITE_FOOTER;

   248

}

   249

   250

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