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 "globals.h"

    19

#include "master.h"

    20

#include "slave.h"

    21

#include "types.h"

    22

#include "device.h"

    23

#include "frame.h"

    24

    25

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

    26

    27

/**

    28

   Konstruktor des EtherCAT-Masters.

    29

*/

    30

    31

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

    32

{

    33

    master->slaves = NULL;

    34

    master->slave_count = 0;

    35

    master->device_registered = 0;

    36

    master->command_index = 0x00;

    37

    master->domain_count = 0;

    38

    master->debug_level = 0;

    39

    master->bus_time = 0;

    40

    master->frames_lost = 0;

    41

    master->t_lost_output = 0;

    42

}

    43

    44

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

    45

    46

/**

    47

   Destruktor eines EtherCAT-Masters.

    48

    49

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

    50

   auf das Slave-Array und gibt die Prozessdaten frei.

    51

*/

    52

    53

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

    54

{

    55

    ec_master_reset(master);

    56

    ec_device_clear(&master->device);

    57

}

    58

    59

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

    60

    61

/**

    62

   Setzt den Master zurück in den Ausgangszustand.

    63

    64

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

    65

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

    66

*/

    67

    68

void ec_master_reset(ec_master_t *master

    69

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

    70

                     )

    71

{

    72

    unsigned int i;

    73

    74

    ec_master_clear_slaves(master);

    75

    76

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

    77

        ec_domain_clear(master->domains[i]);

    78

        kfree(master->domains[i]);

    79

    }

    80

    master->domain_count = 0;

    81

    82

    master->command_index = 0;

    83

    master->debug_level = 0;

    84

    master->bus_time = 0;

    85

    master->frames_lost = 0;

    86

    master->t_lost_output = 0;

    87

}

    88

    89

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

    90

    91

/**

    92

   Entfernt alle Slaves.

    93

*/

    94

    95

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

    96

{

    97

    unsigned int i;

    98

    99

    if (master->slaves) {

   100

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

   101

            ec_slave_clear(master->slaves + i);

   102

        }

   103

        kfree(master->slaves);

   104

        master->slaves = NULL;

   105

    }

   106

    master->slave_count = 0;

   107

}

   108

   109

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

   110

   111

/**

   112

   Öffnet das EtherCAT-Geraet des Masters.

   113

   114

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

   115

   es nicht geoeffnet werden konnte.

   116

*/

   117

   118

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

   119

{

   120

    if (!master->device_registered) {

   121

        printk(KERN_ERR "EtherCAT: No device registered!\n");

   122

        return -1;

   123

    }

   124

   125

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

   126

        printk(KERN_ERR "EtherCAT: Could not open device!\n");

   127

        return -1;

   128

    }

   129

   130

    return 0;

   131

}

   132

   133

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

   134

   135

/**

   136

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

   137

*/

   138

   139

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

   140

{

   141

    if (!master->device_registered) {

   142

        printk(KERN_WARNING "EtherCAT: Warning -"

   143

               " Trying to close an unregistered device!\n");

   144

        return;

   145

    }

   146

   147

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

   148

        printk(KERN_WARNING "EtherCAT: Warning - Could not close device!\n");

   149

    }

   150

}

   151

   152

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

   153

   154

/**

   155

   Durchsucht den Bus nach Slaves.

   156

   157

   @return 0 bei Erfolg, sonst < 0

   158

*/

   159

   160

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

   161

{

   162

    ec_frame_t frame;

   163

    ec_slave_t *slave;

   164

    ec_slave_ident_t *ident;

   165

    unsigned int i;

   166

    unsigned char data[2];

   167

   168

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

   169

        printk(KERN_WARNING "EtherCAT: Slave scan already done!\n");

   170

    ec_master_clear_slaves(master);

   171

   172

    // Determine number of slaves on bus

   173

   174

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

   175

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

   176

   177

    master->slave_count = frame.working_counter;

   178

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

   179

   180

    if (!master->slave_count) return 0;

   181

   182

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

   183

                                                      * sizeof(ec_slave_t),

   184

                                                      GFP_KERNEL))) {

   185

        printk(KERN_ERR "EtherCAT: Could not allocate memory for bus"

   186

               " slaves!\n");

   187

        return -1;

   188

    }

   189

   190

    // Init slaves

   191

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

   192

        slave = master->slaves + i;

   193

        ec_slave_init(slave, master);

   194

        slave->ring_position = i;

   195

        slave->station_address = i + 1;

   196

    }

   197

   198

    // For every slave in the list

   199

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

   200

    {

   201

        slave = master->slaves + i;

   202

   203

        // Write station address

   204

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

   205

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

   206

   207

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

   208

                           data);

   209

   210

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

   211

   212

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

   213

            printk(KERN_ERR "EtherCAT: Slave %i did not repond while writing"

   214

                   " station address!\n", i);

   215

            return -1;

   216

        }

   217

   218

        // Fetch all slave information

   219

        if (ec_slave_fetch(slave)) return -1;

   220

   221

        // Search for identification in "database"

   222

        ident = slave_idents;

   223

        while (ident) {

   224

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

   225

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

   226

                slave->type = ident->type;

   227

                break;

   228

            }

   229

            ident++;

   230

        }

   231

   232

        if (!slave->type) {

   233

            printk(KERN_WARNING "EtherCAT: Unknown slave device (vendor"

   234

                   " 0x%08X, code 0x%08X) at position %i.\n",

   235

                   slave->sii_vendor_id, slave->sii_product_code, i);

   236

            return 0;

   237

        }

   238

    }

   239

   240

    return 0;

   241

}

   242

   243

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

   244

   245

/**

   246

   Gibt von Zeit zu Zeit die Anzahl verlorener Frames aus.

   247

*/

   248

   249

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

   250

{

   251

    unsigned long int t;

   252

   253

    if (master->frames_lost) {

   254

        rdtscl(t);

   255

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

   256

            printk(KERN_ERR "EtherCAT: %u frame(s) LOST!\n",

   257

                   master->frames_lost);

   258

            master->frames_lost = 0;

   259

            master->t_lost_output = t;

   260

        }

   261

    }

   262

}

   263

   264

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

   265

   266

/**

   267

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

   268

   269

   Gültige Adress-Strings sind Folgende:

   270

   271

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

   272

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

   273

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

   274

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

   275

   276

   \return Zeiger auf Slave bei Erfolg, sonst NULL

   277

*/

   278

   279

ec_slave_t *ec_address(const ec_master_t *master,

   280

                       /**< EtherCAT-Master */

   281

                       const char *address

   282

                       /**< Address-String */

   283

                       )

   284

{

   285

    unsigned long first, second;

   286

    char *remainder, *remainder2;

   287

    unsigned int i;

   288

    int coupler_idx, slave_idx;

   289

    ec_slave_t *slave;

   290

   291

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

   292

   293

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

   294

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - #<SSID> not implemented"

   295

               " yet!\n", address);

   296

        return NULL;

   297

    }

   298

   299

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

   300

    if (remainder == address) {

   301

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - First number empty!\n",

   302

               address);

   303

        return NULL;

   304

    }

   305

   306

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

   307

        if (first < master->slave_count) {

   308

            return master->slaves + first;

   309

        }

   310

   311

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Absolute position"

   312

               " illegal!\n", address);

   313

    }

   314

   315

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

   316

   317

        remainder++;

   318

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

   319

   320

        if (remainder2 == remainder) {

   321

            printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Sencond number"

   322

                   " empty!\n", address);

   323

            return NULL;

   324

        }

   325

   326

        if (remainder2[0]) {

   327

            printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Illegal trailer"

   328

                   " (2)!\n", address);

   329

            return NULL;

   330

        }

   331

   332

        coupler_idx = -1;

   333

        slave_idx = 0;

   334

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

   335

            slave = master->slaves + i;

   336

            if (!slave->type) continue;

   337

   338

            if (strcmp(slave->type->vendor_name, "Beckhoff") == 0 &&

   339

                strcmp(slave->type->product_name, "EK1100") == 0) {

   340

                coupler_idx++;

   341

                slave_idx = 0;

   342

            }

   343

   344

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

   345

        }

   346

    }

   347

   348

    else {

   349

        printk(KERN_ERR "EtherCAT: Bus ID \"%s\" - Illegal trailer!\n",

   350

               address);

   351

    }

   352

   353

    return NULL;

   354

}

   355

   356

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

   357

   358

/**

   359

   Initialisiert eine Sync-Manager-Konfigurationsseite.

   360

   361

   Der mit \a data referenzierte Speicher muss mindestens EC_SYNC_SIZE Bytes

   362

   groß sein.

   363

*/

   364

   365

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

   366

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

   367

                    )

   368

{

   369

    data[0] = sync->physical_start_address & 0xFF;

   370

    data[1] = (sync->physical_start_address >> 8) & 0xFF;

   371

    data[2] = sync->size & 0xFF;

   372

    data[3] = (sync->size >> 8) & 0xFF;

   373

    data[4] = sync->control_byte;

   374

    data[5] = 0x00;

   375

    data[6] = 0x01; // enable

   376

    data[7] = 0x00;

   377

}

   378

   379

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

   380

   381

/**

   382

   Initialisiert eine FMMU-Konfigurationsseite.

   383

   384

   Der mit \a data referenzierte Speicher muss mindestens EC_FMMU_SIZE Bytes

   385

   groß sein.

   386

*/

   387

   388

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

   389

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

   390

                    )

   391

{

   392

    data[0] = fmmu->logical_start_address & 0xFF;

   393

    data[1] = (fmmu->logical_start_address >> 8) & 0xFF;

   394

    data[2] = (fmmu->logical_start_address >> 16) & 0xFF;

   395

    data[3] = (fmmu->logical_start_address >> 24) & 0xFF;

   396

    data[4] = fmmu->sync->size & 0xFF;

   397

    data[5] = (fmmu->sync->size >> 8) & 0xFF;

   398

    data[6] = 0x00; // Logical start bit

   399

    data[7] = 0x07; // Logical end bit

   400

    data[8] = fmmu->sync->physical_start_address & 0xFF;

   401

    data[9] = (fmmu->sync->physical_start_address >> 8) & 0xFF;

   402

    data[10] = 0x00; // Physical start bit

   403

    data[11] = (fmmu->sync->control_byte & 0x04) ? 0x02 : 0x01;

   404

    data[12] = 0x01; // Enable

   405

    data[13] = 0x00; // res.

   406

    data[14] = 0x00; // res.

   407

    data[15] = 0x00; // res.

   408

}

   409

   410

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

   411

 *

   412

 * Echtzeitschnittstelle

   413

 *

   414

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

   415

   416

/**

   417

   Registriert eine neue Domäne.

   418

   419

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

   420

*/

   421

   422

ec_domain_t *EtherCAT_rt_master_register_domain(ec_master_t *master,

   423

                                                /**< Domäne */

   424

                                                ec_domain_mode_t mode,

   425

                                                /**< Modus */

   426

                                                unsigned int timeout_us

   427

                                                /**< Timeout */

   428

                                                )

   429

{

   430

    ec_domain_t *domain;

   431

   432

    if (master->domain_count >= EC_MASTER_MAX_DOMAINS) {

   433

        printk(KERN_ERR "EtherCAT: Maximum number of domains reached!\n");

   434

        return NULL;

   435

    }

   436

   437

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

   438

        printk(KERN_ERR "EthertCAT: Error allocating domain memory!\n");

   439

        return NULL;

   440

    }

   441

   442

    ec_domain_init(domain, master, mode, timeout_us);

   443

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

   444

    master->domain_count++;

   445

   446

    return domain;

   447

}

   448

   449

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

   450

   451

/**

   452

   Konfiguriert alle Slaves und setzt den Operational-Zustand.

   453

   454

   Führt die komplette Konfiguration und Aktivierunge aller registrierten

   455

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

   456

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

   457

   458

   \return 0 bei Erfolg, sonst < 0

   459

*/

   460

   461

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

   462

{

   463

    unsigned int i, j;

   464

    ec_slave_t *slave;

   465

    ec_frame_t frame;

   466

    const ec_sync_t *sync;

   467

    const ec_slave_type_t *type;

   468

    const ec_fmmu_t *fmmu;

   469

    uint8_t data[256];

   470

    uint32_t domain_offset;

   471

   472

    // Domains erstellen

   473

    domain_offset = 0;

   474

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

   475

        ec_domain_t *domain = master->domains[i];

   476

        if (ec_domain_alloc(domain, domain_offset)) {

   477

            printk(KERN_INFO "EtherCAT: Failed to allocate domain %i!\n", i);

   478

            return -1;

   479

        }

   480

        printk(KERN_INFO "EtherCAT: Domain %i - Allocated %i bytes (%i"

   481

               " Frame(s))\n", i, domain->data_size,

   482

               domain->data_size / EC_MAX_FRAME_SIZE + 1);

   483

        domain_offset += domain->data_size;

   484

    }

   485

   486

    // Slaves aktivieren

   487

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

   488

    {

   489

        slave = master->slaves + i;

   490

   491

        // Change state to INIT

   492

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

   493

            return -1;