1

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

     2

 *

     3

 *  m a s t e r . c

     4

 *

     5

 *  Methoden für einen EtherCAT-Master.

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include <linux/module.h>

    12

#include <linux/kernel.h>

    13

#include <linux/string.h>

    14

#include <linux/slab.h>

    15

#include <linux/delay.h>

    16

    17

#include "../include/EtherCAT_rt.h"

    18

#include "../include/EtherCAT_si.h"

    19

#include "globals.h"

    20

#include "master.h"

    21

#include "slave.h"

    22

#include "types.h"

    23

#include "device.h"

    24

#include "frame.h"

    25

    26

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

    27

    28

/**

    29

   Konstruktor des EtherCAT-Masters.

    30

*/

    31

    32

void ec_master_init(ec_master_t *master /**< EtherCAT-Master */)

    33

{

    34

    master->slaves = NULL;

    35

    master->slave_count = 0;

    36

    master->device_registered = 0;

    37

    master->command_index = 0x00;

    38

    master->domain_count = 0;

    39

    master->debug_level = 0;

    40

    master->bus_time = 0;

    41

    master->frames_lost = 0;

    42

    master->t_lost_output = 0;

    43

}

    44

    45

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

    46

    47

/**

    48

   Destruktor eines EtherCAT-Masters.

    49

    50

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

    51

   auf das Slave-Array und gibt die Prozessdaten frei.

    52

*/

    53

    54

void ec_master_clear(ec_master_t *master /**< EtherCAT-Master */)

    55

{

    56

    ec_master_reset(master);

    57

    ec_device_clear(&master->device);

    58

}

    59

    60

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

    61

    62

/**

    63

   Setzt den Master zurück in den Ausgangszustand.

    64

    65

   Bei einem "release" sollte immer diese Funktion aufgerufen werden,

    66

   da sonst Slave-Liste, Domains, etc. weiter existieren.

    67

*/

    68

    69

void ec_master_reset(ec_master_t *master

    70

                     /**< Zeiger auf den zurückzusetzenden Master */

    71

                     )

    72

{

    73

    unsigned int i;

    74

    75

    ec_master_clear_slaves(master);

    76

    77

    for (i = 0; i < master->domain_count; i++) {

    78

        ec_domain_clear(master->domains[i]);

    79

        kfree(master->domains[i]);

    80

    }

    81

    master->domain_count = 0;

    82

    83

    master->command_index = 0;

    84

    master->debug_level = 0;

    85

    master->bus_time = 0;

    86

    master->frames_lost = 0;

    87

    master->t_lost_output = 0;

    88

}

    89

    90

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

    91

    92

/**

    93

   Entfernt alle Slaves.

    94

*/

    95

    96

void ec_master_clear_slaves(ec_master_t *master /**< EtherCAT-Master */)

    97

{

    98

    unsigned int i;

    99

   100

    if (master->slaves) {

   101

        for (i = 0; i < master->slave_count; i++) {

   102

            ec_slave_clear(master->slaves + i);

   103

        }

   104

        kfree(master->slaves);

   105

        master->slaves = NULL;

   106

    }

   107

    master->slave_count = 0;

   108

}

   109

   110

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

   111

   112

/**

   113

   Öffnet das EtherCAT-Geraet des Masters.

   114

   115

   \return 0, wenn alles o.k., < 0, wenn kein Gerät registriert wurde oder

   116

   es nicht geoeffnet werden konnte.

   117

*/

   118

   119

int ec_master_open(ec_master_t *master /**< Der EtherCAT-Master */)

   120

{

   121

    if (!master->device_registered) {

   122

        EC_ERR("No device registered!\n");

   123

        return -1;

   124

    }

   125

   126

    if (ec_device_open(&master->device) < 0) {

   127

        EC_ERR("Could not open device!\n");

   128

        return -1;

   129

    }

   130

   131

    return 0;

   132

}

   133

   134

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

   135

   136

/**

   137

   Schliesst das EtherCAT-Geraet, auf dem der Master arbeitet.

   138

*/

   139

   140

void ec_master_close(ec_master_t *master /**< EtherCAT-Master */)

   141

{

   142

    if (!master->device_registered) {

   143

        EC_WARN("Warning - Trying to close an unregistered device!\n");

   144

        return;

   145

    }

   146

   147

    if (ec_device_close(&master->device) < 0)

   148

        EC_WARN("Warning - Could not close device!\n");

   149

}

   150

   151

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

   152

   153

/**

   154

   Durchsucht den Bus nach Slaves.

   155

   156

   @return 0 bei Erfolg, sonst < 0

   157

*/

   158

   159

int ec_scan_for_slaves(ec_master_t *master /**< EtherCAT-Master */)

   160

{

   161

    ec_frame_t frame;

   162

    ec_slave_t *slave;

   163

    ec_slave_ident_t *ident;

   164

    unsigned int i;

   165

    unsigned char data[2];

   166

   167

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

   168

        EC_WARN("Slave scan already done!\n");

   169

    ec_master_clear_slaves(master);

   170

   171

    // Determine number of slaves on bus

   172

   173

    ec_frame_init_brd(&frame, master, 0x0000, 4);

   174

    if (unlikely(ec_frame_send_receive(&frame) < 0)) return -1;

   175

   176

    master->slave_count = frame.working_counter;

   177

    EC_INFO("Found %i slaves on bus.\n", master->slave_count);

   178

   179

    if (!master->slave_count) return 0;

   180

   181

    if (!(master->slaves = (ec_slave_t *) kmalloc(master->slave_count

   182

                                                      * sizeof(ec_slave_t),

   183

                                                      GFP_KERNEL))) {

   184

        EC_ERR("Could not allocate memory for bus slaves!\n");

   185

        return -1;

   186

    }

   187

   188

    // Init slaves

   189

    for (i = 0; i < master->slave_count; i++) {

   190

        slave = master->slaves + i;

   191

        ec_slave_init(slave, master);

   192

        slave->ring_position = i;

   193

        slave->station_address = i + 1;

   194

    }

   195

   196

    // For every slave in the list

   197

    for (i = 0; i < master->slave_count; i++)

   198

    {

   199

        slave = master->slaves + i;

   200

   201

        // Write station address

   202

        EC_WRITE_U16(data, slave->station_address);

   203

   204

        ec_frame_init_apwr(&frame, master, slave->ring_position, 0x0010,

   205

                           sizeof(uint16_t), data);

   206

   207

        if (unlikely(ec_frame_send_receive(&frame) < 0)) return -1;

   208

   209

        if (unlikely(frame.working_counter != 1)) {

   210

            EC_ERR("Slave %i did not repond while writing station address!\n",

   211

                   i);

   212

            return -1;

   213

        }

   214

   215

        // Fetch all slave information

   216

        if (ec_slave_fetch(slave)) return -1;

   217

   218

        // Search for identification in "database"

   219

        ident = slave_idents;

   220

        while (ident) {

   221

            if (unlikely(ident->vendor_id == slave->sii_vendor_id

   222

                         && ident->product_code == slave->sii_product_code)) {

   223

                slave->type = ident->type;

   224

                break;

   225

            }

   226

            ident++;

   227

        }

   228

   229

        if (!slave->type)

   230

            EC_WARN("Unknown slave device (vendor 0x%08X, code 0x%08X) at"

   231

                    " position %i.\n", slave->sii_vendor_id,

   232

                    slave->sii_product_code, i);

   233

    }

   234

   235

    return 0;

   236

}

   237

   238

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

   239

   240

/**

   241

   Gibt von Zeit zu Zeit die Anzahl verlorener Frames aus.

   242

*/

   243

   244

void ec_output_lost_frames(ec_master_t *master /**< EtherCAT-Master */)

   245

{

   246

    unsigned long int t;

   247

   248

    if (master->frames_lost) {

   249

        rdtscl(t);

   250

        if ((t - master->t_lost_output) / cpu_khz > 1000) {

   251

            EC_WARN("%u frame(s) LOST!\n", master->frames_lost);

   252

            master->frames_lost = 0;

   253

            master->t_lost_output = t;

   254

        }

   255

    }

   256

}

   257

   258

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

   259

   260

/**

   261

   Wandelt eine ASCII-kodierte Bus-Adresse in einen Slave-Zeiger.

   262

   263

   Gültige Adress-Strings sind Folgende:

   264

   265

   - \a "X" = der X. Slave im Bus,

   266

   - \a "X:Y" = der Y. Slave hinter dem X. Buskoppler,

   267

   - \a "#X" = der Slave mit der SSID X,

   268

   - \a "#X:Y" = der Y. Slave hinter dem Buskoppler mit der SSID X.

   269

   270

   \return Zeiger auf Slave bei Erfolg, sonst NULL

   271

*/

   272

   273

ec_slave_t *ec_address(const ec_master_t *master,

   274

                       /**< EtherCAT-Master */

   275

                       const char *address

   276

                       /**< Address-String */

   277

                       )

   278

{

   279

    unsigned long first, second;

   280

    char *remainder, *remainder2;

   281

    unsigned int i;

   282

    int coupler_idx, slave_idx;

   283

    ec_slave_t *slave;

   284

   285

    if (!address || address[0] == 0) return NULL;

   286

   287

    if (address[0] == '#') {

   288

        EC_ERR("Bus ID \"%s\" - #<SSID> not implemented yet!\n", address);

   289

        return NULL;

   290

    }

   291

   292

    first = simple_strtoul(address, &remainder, 0);

   293

    if (remainder == address) {

   294

        EC_ERR("Bus ID \"%s\" - First number empty!\n", address);

   295

        return NULL;

   296

    }

   297

   298

    if (!remainder[0]) { // absolute position

   299

        if (first < master->slave_count) {

   300

            return master->slaves + first;

   301

        }

   302

   303

        EC_ERR("Bus ID \"%s\" - Absolute position illegal!\n", address);

   304

    }

   305

   306

    else if (remainder[0] == ':') { // field position

   307

   308

        remainder++;

   309

        second = simple_strtoul(remainder, &remainder2, 0);

   310

   311

        if (remainder2 == remainder) {

   312

            EC_ERR("Bus ID \"%s\" - Sencond number empty!\n", address);

   313

            return NULL;

   314

        }

   315

   316

        if (remainder2[0]) {

   317

            EC_ERR("Bus ID \"%s\" - Illegal trailer (2)!\n", address);

   318

            return NULL;

   319

        }

   320

   321

        coupler_idx = -1;

   322

        slave_idx = 0;

   323

        for (i = 0; i < master->slave_count; i++, slave_idx++) {

   324

            slave = master->slaves + i;

   325

            if (!slave->type) continue;

   326

   327

            if (slave->type->bus_coupler) {

   328

                coupler_idx++;

   329

                slave_idx = 0;

   330

            }

   331

   332

            if (coupler_idx == first && slave_idx == second) return slave;

   333

        }

   334

    }

   335

   336

    else

   337

        EC_ERR("Bus ID \"%s\" - Illegal trailer!\n", address);

   338

   339

    // FIXME ???

   340

   341

    return NULL;

   342

}

   343

   344

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

   345

   346

/**

   347

   Initialisiert eine Sync-Manager-Konfigurationsseite.

   348

   349

   Der mit \a data referenzierte Speicher muss mindestens EC_SYNC_SIZE Bytes

   350

   groß sein.

   351

*/

   352

   353

void ec_sync_config(const ec_sync_t *sync, /**< Sync-Manager */

   354

                    uint8_t *data /**> Zeiger auf Konfigurationsspeicher */

   355

                    )

   356

{

   357

    EC_WRITE_U16(data,     sync->physical_start_address);

   358

    EC_WRITE_U16(data + 2, sync->size);

   359

    EC_WRITE_U8 (data + 4, sync->control_byte);

   360

    EC_WRITE_U8 (data + 5, 0x00); // status byte (read only)

   361

    EC_WRITE_U16(data + 6, 0x0001); // enable

   362

}

   363

   364

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

   365

   366

/**

   367

   Initialisiert eine FMMU-Konfigurationsseite.

   368

   369

   Der mit \a data referenzierte Speicher muss mindestens EC_FMMU_SIZE Bytes

   370

   groß sein.

   371

*/

   372

   373

void ec_fmmu_config(const ec_fmmu_t *fmmu, /**< Sync-Manager */

   374

                    uint8_t *data /**> Zeiger auf Konfigurationsspeicher */

   375

                    )

   376

{

   377

    EC_WRITE_U32(data,      fmmu->logical_start_address);

   378

    EC_WRITE_U16(data + 4,  fmmu->sync->size);

   379

    EC_WRITE_U8 (data + 6,  0x00); // Logical start bit

   380

    EC_WRITE_U8 (data + 7,  0x07); // Logical end bit

   381

    EC_WRITE_U16(data + 8,  fmmu->sync->physical_start_address);

   382

    EC_WRITE_U8 (data + 10, 0x00); // Physical start bit

   383

    EC_WRITE_U8 (data + 11, (fmmu->sync->control_byte & 0x04) ? 0x02 : 0x01);

   384

    EC_WRITE_U16(data + 12, 0x0001); // Enable

   385

    EC_WRITE_U16(data + 14, 0x0000); // res.

   386

}

   387

   388

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

   389

 *

   390

 * Echtzeitschnittstelle

   391

 *

   392

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

   393

   394

/**

   395

   Registriert eine neue Domäne.

   396

   397

   \return Zeiger auf die Domäne bei Erfolg, sonst NULL.

   398

*/

   399

   400

ec_domain_t *EtherCAT_rt_master_register_domain(ec_master_t *master,

   401

                                                /**< Domäne */

   402

                                                ec_domain_mode_t mode,

   403

                                                /**< Modus */

   404

                                                unsigned int timeout_us

   405

                                                /**< Timeout */

   406

                                                )

   407

{

   408

    ec_domain_t *domain;

   409

   410

    if (master->domain_count >= EC_MASTER_MAX_DOMAINS) {

   411

        EC_ERR("Maximum number of domains reached!\n");

   412

        return NULL;

   413

    }

   414

   415

    if (!(domain = (ec_domain_t *) kmalloc(sizeof(ec_domain_t), GFP_KERNEL))) {

   416

        EC_ERR("Error allocating domain memory!\n");

   417

        return NULL;

   418

    }

   419

   420

    ec_domain_init(domain, master, mode, timeout_us);

   421

    master->domains[master->domain_count] = domain;

   422

    master->domain_count++;

   423

   424

    return domain;

   425

}

   426

   427

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

   428

   429

/**

   430

   Konfiguriert alle Slaves und setzt den Operational-Zustand.

   431

   432

   Führt die komplette Konfiguration und Aktivierunge aller registrierten

   433

   Slaves durch. Setzt Sync-Manager und FMMU's, führt die entsprechenden

   434

   Zustandsübergänge durch, bis der Slave betriebsbereit ist.

   435

   436

   \return 0 bei Erfolg, sonst < 0

   437

*/

   438

   439

int EtherCAT_rt_master_activate(ec_master_t *master /**< EtherCAT-Master */)

   440

{

   441

    unsigned int i, j;

   442

    ec_slave_t *slave;

   443

    ec_frame_t frame;

   444

    const ec_sync_t *sync;

   445

    const ec_slave_type_t *type;

   446

    const ec_fmmu_t *fmmu;

   447

    uint8_t data[256];

   448

    uint32_t domain_offset;

   449

    unsigned int frame_count;

   450

    ec_domain_t *domain;

   451

   452

    // Domains erstellen

   453

    domain_offset = 0;

   454

    for (i = 0; i < master->domain_count; i++) {

   455

        domain = master->domains[i];

   456

        if (ec_domain_alloc(domain, domain_offset)) {

   457

            EC_ERR("Failed to allocate domain %i!\n", i);

   458

            return -1;

   459

        }

   460

        frame_count = domain->data_size / EC_MAX_FRAME_SIZE + 1;

   461

        if (!domain->data_size) frame_count = 0;

   462

        EC_INFO("Domain %i - Allocated %i bytes (%i Frame(s))\n", i,

   463

                domain->data_size, frame_count);

   464

        domain_offset += domain->data_size;

   465

    }

   466

   467

    // Slaves aktivieren

   468

    for (i = 0; i < master->slave_count; i++)

   469

    {

   470

        slave = master->slaves + i;

   471

   472

        // Change state to INIT

   473

        if (unlikely(ec_slave_state_change(slave, EC_SLAVE_STATE_INIT)))

   474

            return -1;

   475

   476

        // Check if slave was registered...

   477

        if (!slave->type) {

   478

            EC_WARN("Slave %i has unknown type!\n", i);

   479

            continue;

   480

        }

   481

   482

        type = slave->type;

   483

   484

        // Check and reset CRC fault counters

   485

        ec_slave_check_crc(slave);

   486

   487

        // Resetting FMMU's

   488

        if (slave->base_fmmu_count) {

   489

            memset(data, 0x00, EC_FMMU_SIZE * slave->base_fmmu_count);

   490

            ec_frame_init_npwr(&frame, master, slave->station_address, 0x0600,