1

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

     2

 *

     3

 *  e c _ m a s t e r . c

     4

 *

     5

 *  Methoden für einen EtherCAT-Master.

     6

 *

     7

 *  $Date$

     8

 *  $Author$

     9

 *

    10

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

    11

    12

#include <linux/kernel.h>

    13

#include <linux/string.h>

    14

#include <linux/slab.h>

    15

#include <linux/delay.h>

    16

    17

#include "ec_globals.h"

    18

#include "ec_master.h"

    19

#include "ec_dbg.h"

    20

    21

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

    22

    23

/**

    24

   Konstruktor des EtherCAT-Masters.

    25

    26

   @param master Zeiger auf den zu initialisierenden

    27

   EtherCAT-Master

    28

   @param dev Zeiger auf das EtherCAT-gerät, mit dem der

    29

   Master arbeiten soll

    30

    31

   @return 0 bei Erfolg, sonst < 0 (= dev ist NULL)

    32

*/

    33

    34

int EtherCAT_master_init(EtherCAT_master_t *master,

    35

                         EtherCAT_device_t *dev)

    36

{

    37

  unsigned int i;

    38

    39

  if (!dev)

    40

  {

    41

    EC_DBG(KERN_ERR "EtherCAT: Master init without device!\n");

    42

    return -1;

    43

  }

    44

    45

  master->slaves = NULL;

    46

  master->slave_count = 0;

    48

  //master->process_data_command = NULL;

    49

  master->dev = dev;

    50

  master->command_index = 0x00;

    51

  master->tx_data_length = 0;

    52

  master->process_data = NULL;

    53

  master->process_data_length = 0;

    55

  master->debug_level = 0;

    56

    58

  for (i = 0; i < ECAT_COMMAND_RING_SIZE; i++)

    59

  {

    60

    EtherCAT_command_init(&master->cmd_ring[i]);

    61

    master->cmd_reserved[i] = 0;

    62

  }

    64

    65

  return 0;

    66

}

    67

    68

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

    69

    70

/**

    71

   Destruktor eines EtherCAT-Masters.

    72

    73

   Entfernt alle Kommandos aus der Liste, löscht den Zeiger

    74

   auf das Slave-Array und gibt die Prozessdaten frei.

    75

    76

   @param master Zeiger auf den zu löschenden Master

    77

*/

    78

    79

void EtherCAT_master_clear(EtherCAT_master_t *master)

    80

{

    81

#if 0

    82

  // Remove all pending commands

    83

  while (master->first_command)

    84

  {

    85

    EtherCAT_remove_command(master, master->first_command);

    86

  }

    87

#endif

    88

    89

  // Remove all slaves

    90

  EtherCAT_clear_slaves(master);

    91

    92

  if (master->process_data)

    93

  {

    94

    kfree(master->process_data);

    95

    master->process_data = NULL;

    96

  }

    97

    98

  master->process_data_length = 0;

    99

}

   100

   101

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

   102

   103

/**

   104

   Überprüft die angeschlossenen Slaves.

   105

   106

   Vergleicht die an den Bus angeschlossenen Slaves mit

   107

   den im statischen-Slave-Array vorgegebenen Konfigurationen.

   108

   Stimmen Anzahl oder Typen nicht überein, gibt diese

   109

   Methode einen Fehler aus.

   110

   111

   @param master Der EtherCAT-Master

   112

   @param slaves Zeiger auf ein statisches Slave-Array

   113

   @param slave_count Anzahl der Slaves im Array

   114

   115

   @return 0 bei Erfolg, sonst < 0

   116

*/

   117

   118

int EtherCAT_check_slaves(EtherCAT_master_t *master,

   119

                          EtherCAT_slave_t *slaves,

   120

                          unsigned int slave_count)

   121

{

   122

  EtherCAT_command_t cmd;

   123

  EtherCAT_slave_t *cur;

   124

  unsigned int i, j, found, length, pos;

   125

  unsigned char data[2];

   126

   127

  // EtherCAT_clear_slaves() must be called before!

   128

  if (master->slaves || master->slave_count)

   129

  {

   130

    EC_DBG(KERN_ERR "EtherCAT duplicate slave check!");

   131

    return -1;

   132

  }

   133

   134

  // No slaves.

   135

  if (slave_count == 0)

   136

  {

   137

    EC_DBG(KERN_ERR "EtherCAT: No slaves in list!");

   138

    return -1;

   139

  }

   140

   141

  // Determine number of slaves on bus

   142

   143

  EtherCAT_command_broadcast_read(&cmd, 0x0000, 4);

   144

   145

  if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1;

   146

   147

  if (cmd.working_counter != slave_count)

   148

  {

   149

    EC_DBG(KERN_ERR "EtherCAT: Wrong number of slaves on bus: %i / %i\n",

   150

           cmd.working_counter, slave_count);

   151

    return -1;

   152

  }

   153

  else

   154

  {

   155

    EC_DBG("EtherCAT: Found all %i slaves.\n", slave_count);

   156

  }

   157

   158

  // For every slave in the list

   159

  for (i = 0; i < slave_count; i++)

   160

  {

   161

    cur = &slaves[i];

   162

   163

    if (!cur->desc)

   164

    {

   165

      EC_DBG(KERN_ERR "EtherCAT: Slave %i has no description.\n", i);

   166

      return -1;

   167

    }

   168

   169

    // Set ring position

   170

    cur->ring_position = -i;

   171

    cur->station_address = i + 1;

   172

   173

    // Write station address

   174

   175

    data[0] = cur->station_address & 0x00FF;

   176

    data[1] = (cur->station_address & 0xFF00) >> 8;

   177

   178

    EtherCAT_command_position_write(&cmd, cur->ring_position, 0x0010, 2, data);

   179

    if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1;

   180

   181

    if (cmd.working_counter != 1)

   182

    {

   183

      EC_DBG(KERN_ERR "EtherCAT: Slave %i did not repond while writing station address!\n", i);

   184

      return -1;

   185

    }

   186

   187

    // Read base data

   188

   189

    EtherCAT_command_read(&cmd, cur->station_address, 0x0000, 4);

   190

    if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -1;

   191

   192

    if (cmd.working_counter != 1)

   193

    {

   194

      EC_DBG(KERN_ERR "EtherCAT: Slave %i did not respond while reading base data!\n", i);

   195

      return -1;

   196

    }

   197

   198

    // Get base data

   199

    cur->type = cmd.data[0];

   200

    cur->revision = cmd.data[1];

   201

    cur->build = cmd.data[2] | (cmd.data[3] << 8);

   202

   203

    // Read identification from "Slave Information Interface" (SII)

   204

   205

    if (EtherCAT_read_slave_information(master, cur->station_address,

   206

                                        0x0008, &cur->vendor_id) != 0)

   207

    {

   208

      EC_DBG(KERN_ERR "EtherCAT: Could not read SII vendor id!\n");

   209

      return -1;

   210

    }

   211

   212

    if (EtherCAT_read_slave_information(master, cur->station_address,

   213

                                        0x000A, &cur->product_code) != 0)

   214

    {

   215

      EC_DBG(KERN_ERR "EtherCAT: Could not read SII product code!\n");

   216

      return -1;

   217

    }

   218

   219

    if (EtherCAT_read_slave_information(master, cur->station_address,

   220

                                        0x000E, &cur->revision_number) != 0)

   221

    {

   222

      EC_DBG(KERN_ERR "EtherCAT: Could not read SII revision number!\n");

   223

      return -1;

   224

    }

   225

   226

    if (EtherCAT_read_slave_information(master, cur->station_address,

   227

                                        0x0012, &cur->serial_number) != 0)

   228

    {

   229

      EC_DBG(KERN_ERR "EtherCAT: Could not read SII serial number!\n");

   230

      return -1;

   231

    }

   232

   233

    // Search for identification in "database"

   234

   235

    found = 0;

   236

   237

    for (j = 0; j < slave_idents_count; j++)

   238

    {

   239

      if (slave_idents[j].vendor_id == cur->vendor_id

   240

          && slave_idents[j].product_code == cur->product_code)

   241

      {

   242

        found = 1;

   243

   244

        if (cur->desc != slave_idents[j].desc)

   245

        {

   246

          EC_DBG(KERN_ERR "EtherCAT: Unexpected slave device \"%s %s\""

   247

                 " at position %i. Expected: \"%s %s\"\n",

   248

                 slave_idents[j].desc->vendor_name,

   249

                 slave_idents[j].desc->product_name, i,

   250

                 cur->desc->vendor_name, cur->desc->product_name);

   251

          return -1;

   252

        }

   253

   254

        break;

   255

      }

   256

    }

   257

   258

    if (!found)

   259

    {

   260

      EC_DBG(KERN_ERR "EtherCAT: Unknown slave device"

   261

             " (vendor %X, code %X) at position %i.\n",

   262

             i, cur->vendor_id, cur->product_code);

   263

      return -1;

   264

    }

   265

  }

   266

   267

  length = 0;

   268

  for (i = 0; i < slave_count; i++)

   269

  {

   270

    length += slaves[i].desc->data_length;

   271

  }

   272

   273

  if ((master->process_data = (unsigned char *)

   274

       kmalloc(sizeof(unsigned char) * length, GFP_KERNEL)) == NULL)

   275

  {

   276

    EC_DBG(KERN_ERR "EtherCAT: Could not allocate %i bytes for process data.\n", length);

   277

    return -1;

   278

  }

   279

   280

  master->process_data_length = length;

   281

  memset(master->process_data, 0x00, length);

   282

   283

  pos = 0;

   284

  for (i = 0; i < slave_count; i++)

   285

  {

   286

    slaves[i].process_data = master->process_data + pos;

   287

    slaves[i].logical_address0 = pos;

   288

   289

    EC_DBG(KERN_DEBUG "EtherCAT: Slave %i - Address 0x%X, \"%s %s\", s/n %u\n",

   290

           i, pos, slaves[i].desc->vendor_name, slaves[i].desc->product_name,

   291

           slaves[i].serial_number);

   292

   293

    pos += slaves[i].desc->data_length;

   294

  }

   295

   296

  master->slaves = slaves;

   297

  master->slave_count = slave_count;

   298

   299

  return 0;

   300

}

   301

   302

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

   303

   304

/**

   305

   Entfernt den Zeiger auf das Slave-Array.

   306

   307

   @param master EtherCAT-Master

   308

*/

   309

   310

void EtherCAT_clear_slaves(EtherCAT_master_t *master)

   311

{

   312

  master->slaves = NULL;

   313

  master->slave_count = 0;

   314

}

   315

   316

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

   317

   318

/**

   319

   Liest Daten aus dem Slave-Information-Interface

   320

   eines EtherCAT-Slaves.

   321

   322

   @param master EtherCAT-Master

   323

   @param node_address Knotenadresse des Slaves

   324

   @param offset Adresse des zu lesenden SII-Registers

   325

   @param target Zeiger auf einen 4 Byte großen Speicher

   326

   zum Ablegen der Daten

   327

   328

   @return 0 bei Erfolg, sonst < 0

   329

*/

   330

   331

int EtherCAT_read_slave_information(EtherCAT_master_t *master,

   332

                                    unsigned short int node_address,

   333

                                    unsigned short int offset,

   334

                                    unsigned int *target)

   335

{

   336

  EtherCAT_command_t cmd;

   337

  unsigned char data[10];

   338

  unsigned int tries_left;

   339

   340

  // Initiate read operation

   341

   342

  data[0] = 0x00;

   343

  data[1] = 0x01;

   344

  data[2] = offset & 0xFF;

   345

  data[3] = (offset & 0xFF00) >> 8;

   346

  data[4] = 0x00;

   347

  data[5] = 0x00;

   348

   349

  EtherCAT_command_write(&cmd, node_address, 0x502, 6, data);

   350

  if (EtherCAT_simple_send_receive(master, &cmd) < 0) return -3;

   351

   352

  if (cmd.working_counter != 1)

   353

  {

   354

    EC_DBG(KERN_ERR "EtherCAT: SII-read - Slave %04X did not respond!\n",

   355

           node_address);

   356

    return -4;

   357

  }

   358

   359

  // Der Slave legt die Informationen des Slave-Information-Interface

   360

  // in das Datenregister und löscht daraufhin ein Busy-Bit. Solange

   361

  // den Status auslesen, bis das Bit weg ist.

   362

   363

  tries_left = 100;

   364

  while (tries_left)

   365

  {

   366

    udelay(10);

   367

   368

    EtherCAT_command_read(&cmd, node_address, 0x502, 10);

   369

    if (EtherCAT_simple_send_receive(master, &cmd) != 0) return -3;

   370

   371

    if (cmd.working_counter != 1)

   372

    {

   373

      EC_DBG(KERN_ERR "EtherCAT: SII-read status - Slave %04X did not respond!\n",

   374

             node_address);

   375

      return -4;

   376

    }

   377

   378

    if ((cmd.data[1] & 0x81) == 0)

   379

    {

   380

      memcpy(target, cmd.data + 6, 4);

   381

      break;

   382

    }

   383

   384

    tries_left--;

   385

  }

   386

   387

  if (!tries_left)

   388

  {

   389

    EC_DBG(KERN_WARNING "EtherCAT: SSI-read. Slave %04X timed out!\n",

   390

           node_address);

   391

    return -1;

   392

  }

   393

   394

  return 0;

   395

}

   396

   397

#if 0

   398

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

   399

   400

/**

   401

   Führt ein asynchrones Senden und Empfangen aus.

   402

   403

   Sendet alle wartenden Kommandos und wartet auf die

   404

   entsprechenden Antworten.

   405

   406

   @param master EtherCAT-Master

   407

   408

   @return 0 bei Erfolg, sonst < 0

   409

*/

   410

   411

int EtherCAT_async_send_receive(EtherCAT_master_t *master)

   412

{

   413

  unsigned int wait_cycles;

   414

  int i;

   415

   416

  // Send all commands

   417

   418

  for (i = 0; i < ECAT_NUM_RETRIES; i++)

   419

  {

   420

    if (EtherCAT_send(master) < 0)

   421

    {

   422

      return -1;

   423

    }

   424

   425

    // Wait until something is received or an error has occurred

   426

   427

    wait_cycles = 10;

   428

    EtherCAT_device_call_isr(master->dev);

   429

   430

    while (master->dev->state == ECAT_DS_SENT && wait_cycles)

   431

    {

   432

      udelay(1000);

   433

      wait_cycles--;

   434

      EtherCAT_device_call_isr(master->dev);

   435

    }

   436

   437

    //EC_DBG("Master async send: tries %d",tries_left);

   438

   439

    if (!wait_cycles)

   440

    {

   441

      EC_DBG(KERN_ERR "EtherCAT: Asynchronous receive timeout.\n");

   442

      continue;

   443

    }

   444

   445

    if (master->dev->state != ECAT_DS_RECEIVED)

   446

    {

   447

      EC_DBG(KERN_ERR "EtherCAT: Asyncronous send error. State %i\n", master->dev->state);

   448

      continue;

   449

    }

   450

   451

    // Receive all commands

   452

    if (EtherCAT_receive(master) < 0)

   453

    {

   454

      // Noch mal versuchen

   455

      master->dev->state = ECAT_DS_READY;

   456

      EC_DBG("Retry Asynchronous send/recieve: %d", i);

   457

      continue;

   458

    }

   459

   460

    return 0; // Erfolgreich

   461

  }

   462

   463

  return -1;

   464

}

   465

   466

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

   467

   468

/**

   469

   Sendet alle wartenden Kommandos.

   470

   471

   Errechnet erst die benötigte Gesamt-Rahmenlänge, und erstellt

   472

   dann alle Kommando-Bytefolgen im statischen Sendespeicher.

   473

   Danach wird die Sendefunktion des EtherCAT-Gerätes aufgerufen.

   474

   475

   @param master EtherCAT-Master

   476

   477

   @return 0 bei Erfolg, sonst < 0

   478

*/

   479

   480

int EtherCAT_send(EtherCAT_master_t *master)

   481

{

   482

  unsigned int i, length, framelength, pos;

   483

  EtherCAT_command_t *cmd;

   484

  int cmdcnt = 0;

   485

   486

  if (master->debug_level > 0)

   487

  {

   488

    EC_DBG(KERN_DEBUG "EtherCAT_send, first_command = %X\n", (int) master->first_command);

   489

  }

   490

   491

  length = 0;

   492

  for (cmd = master->first_command; cmd != NULL; cmd = cmd->next)

   493

  {

   494

    if (cmd->state != ECAT_CS_READY) continue;

   495

    length += cmd->data_length + 12;

   496

    cmdcnt++;

   497

  }

   498

   499

  if (master->debug_level > 0)

   500

  {

   501

    EC_DBG(KERN_DEBUG "%i commands to send.\n", cmdcnt);

   502

  }

   503

   504

  if (length == 0)

   505

  {

   506

    EC_DBG(KERN_WARNING "EtherCAT: Nothing to send...\n");

   507

    return 0;

   508

  }

   509

   510

  framelength = length + 2;

   511

  if (framelength < 46) framelength = 46;

   512

   513

  if (master->debug_level > 0)

   514

  {

   515

    EC_DBG(KERN_DEBUG "framelength: %i\n", framelength);