1

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

     2

 *

     3

 *  d o m a i n . c

     4

 *

     5

 *  Methoden für Gruppen von EtherCAT-Slaves.

     6

 *

     7

 *  $Id$

     8

 *

     9

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

    10

    11

#include "globals.h"

    12

#include "domain.h"

    13

#include "master.h"

    14

    15

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

    16

    17

/**

    18

   Konstruktor einer EtherCAT-Domäne.

    19

*/

    20

    21

void ec_domain_init(ec_domain_t *domain, /**< Domäne */

    22

                    ec_master_t *master, /**< Zugehöriger Master */

    23

                    ec_domain_mode_t mode, /**< Synchron/Asynchron */

    24

                    unsigned int timeout_us /**< Timeout in Mikrosekunden */

    25

                    )

    26

{

    27

    domain->master = master;

    28

    domain->mode = mode;

    29

    domain->timeout_us = timeout_us;

    30

    31

    domain->data = NULL;

    32

    domain->data_size = 0;

    33

    domain->base_address = 0;

    34

    domain->response_count = 0xFFFFFFFF;

    35

    36

    INIT_LIST_HEAD(&domain->field_regs);

    37

}

    38

    39

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

    40

    41

/**

    42

   Destruktor einer EtherCAT-Domäne.

    43

*/

    44

    45

void ec_domain_clear(ec_domain_t *domain /**< Domäne */)

    46

{

    47

    ec_field_reg_t *field_reg, *next;

    48

    49

    if (domain->data) {

    50

        kfree(domain->data);

    51

        domain->data = NULL;

    52

    }

    53

    54

    // Liste der registrierten Datenfelder löschen

    55

    list_for_each_entry_safe(field_reg, next, &domain->field_regs, list) {

    56

        kfree(field_reg);

    57

    }

    58

}

    59

    60

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

    61

    62

/**

    63

   Registriert ein Feld in einer Domäne.

    64

    66

*/

    67

    68

int ec_domain_reg_field(ec_domain_t *domain, /**< Domäne */

    69

                        ec_slave_t *slave, /**< Slave */

    70

                        const ec_sync_t *sync, /**< Sync-Manager */

    71

                        uint32_t field_offset, /**< Datenfeld-Offset */

    72

                        void **data_ptr /**< Adresse des Prozessdatenzeigers */

    73

                        )

    74

{

    75

    ec_field_reg_t *field_reg;

    76

    77

    if (!(field_reg = (ec_field_reg_t *) kmalloc(sizeof(ec_field_reg_t),

    78

                                                 GFP_KERNEL))) {

    79

        EC_ERR("Failed to allocate field registration.\n");

    80

        return -1;

    81

    }

    82

    83

    if (ec_slave_set_fmmu(slave, domain, sync)) {

    84

        EC_ERR("FMMU configuration failed.\n");

    85

        kfree(field_reg);

    86

        return -1;

    87

    }

    88

    89

    field_reg->slave = slave;

    90

    field_reg->sync = sync;

    91

    field_reg->field_offset = field_offset;

    92

    field_reg->data_ptr = data_ptr;

    93

    94

    list_add_tail(&field_reg->list, &domain->field_regs);

    95

    96

    return 0;

    97

}

    98

    99

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

   100

   101

/**

   108

*/

   109

   110

int ec_domain_alloc(ec_domain_t *domain, /**< Domäne */

   111

                    uint32_t base_address /**< Logische Basisadresse */

   112

                    )

   113

{

   114

    ec_field_reg_t *field_reg, *next;

   115

    ec_slave_t *slave;

   116

    ec_fmmu_t *fmmu;

   117

    unsigned int i, j, found, data_offset;

   118

   119

    if (domain->data) {

   120

        EC_ERR("Domain already allocated!\n");

   121

        return -1;

   122

    }

   123

   124

    domain->base_address = base_address;

   125

   126

    // Größe der Prozessdaten berechnen

   127

    // und logische Adressen der FMMUs setzen

   128

    domain->data_size = 0;

   129

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

   130

        slave = &domain->master->slaves[i];

   131

        for (j = 0; j < slave->fmmu_count; j++) {

   132

            fmmu = &slave->fmmus[j];

   133

            if (fmmu->domain == domain) {

   134

                fmmu->logical_start_address = base_address + domain->data_size;

   135

                domain->data_size += fmmu->sync->size;

   136

            }

   137

        }

   138

    }

   139

   140

    if (!domain->data_size) {

   141

        EC_WARN("Domain 0x%08X contains no data!\n", (u32) domain);

   142

    }

   143

    else {

   144

        // Prozessdaten allozieren

   145

        if (!(domain->data = kmalloc(domain->data_size, GFP_KERNEL))) {

   146

            EC_ERR("Failed to allocate domain data!\n");

   147

            return -1;

   148

        }

   149

   150

        // Prozessdaten mit Nullen vorbelegen

   151

        memset(domain->data, 0x00, domain->data_size);

   152

   153

        // Alle Prozessdatenzeiger setzen

   154

        list_for_each_entry(field_reg, &domain->field_regs, list) {

   155

            found = 0;

   156

            for (i = 0; i < field_reg->slave->fmmu_count; i++) {

   157

                fmmu = &field_reg->slave->fmmus[i];

   158

                if (fmmu->domain == domain && fmmu->sync == field_reg->sync) {

   159

                    data_offset = fmmu->logical_start_address - base_address

   160

                        + field_reg->field_offset;

   161

                    *field_reg->data_ptr = domain->data + data_offset;

   162

                    found = 1;

   163

                    break;

   164

                }

   165

            }

   166

   167

            if (!found) { // Sollte nie passieren

   168

                EC_ERR("FMMU not found. Please report!\n");

   169

                return -1;

   170

            }

   171

        }

   172

    }

   173

   174

    // Registrierungsliste wird jetzt nicht mehr gebraucht.

   175

    list_for_each_entry_safe(field_reg, next, &domain->field_regs, list) {

   176

        kfree(field_reg);

   177

    }

   178

    INIT_LIST_HEAD(&domain->field_regs); // wichtig!

   179

   180

    return 0;

   181

}

   182

   183

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

   184

 *

   185

 * Echtzeitschnittstelle

   186

 *

   187

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

   188

   189

/**

   191

   192

   \return Zeiger auf den Slave bei Erfolg, sonst NULL

   193

*/

   194

   195

ec_slave_t *EtherCAT_rt_register_slave_field(

   196

    ec_domain_t *domain, /**< Domäne */

   197

    const char *address, /**< ASCII-Addresse des Slaves, siehe ec_address() */

   198

    const char *vendor_name, /**< Herstellername */

   199

    const char *product_name, /**< Produktname */

   200

    void **data_ptr, /**< Adresse des Zeigers auf die Prozessdaten */

   201

    ec_field_type_t field_type, /**< Typ des Datenfeldes */

   202

    unsigned int field_index, /**< Gibt an, ab welchem Feld mit Typ

   203

                                 \a field_type gezählt werden soll. */

   204

    unsigned int field_count /**< Anzahl Felder des selben Typs */

   205

    )

   206

{

   207

    ec_slave_t *slave;

   208

    const ec_slave_type_t *type;

   209

    ec_master_t *master;

   210

    const ec_sync_t *sync;

   211

    const ec_field_t *field;

   212

    unsigned int field_idx, i, j;

   213

    uint32_t field_offset;

   214

   215

    if (!field_count) {

   216

        EC_ERR("field_count may not be 0!\n");

   217

        return NULL;

   218

    }

   219

   220

    master = domain->master;

   221

   222

    // Adresse übersetzen

   223

    if ((slave = ec_address(master, address)) == NULL) return NULL;

   224

   225

    if (!(type = slave->type)) {

   226

        EC_ERR("Slave \"%s\" (position %i) has unknown type!\n", address,

   227

               slave->ring_position);

   228

        return NULL;

   229

    }

   230

   231

    if (strcmp(vendor_name, type->vendor_name) ||

   232

        strcmp(product_name, type->product_name)) {

   233

        EC_ERR("Invalid slave type at position %i - Requested: \"%s %s\","

   234

               " found: \"%s %s\".\n", slave->ring_position, vendor_name,

   235

               product_name, type->vendor_name, type->product_name);

   236

        return NULL;

   237

    }

   238

   239

    field_idx = 0;

   240

    for (i = 0; type->sync_managers[i]; i++) {

   241

        sync = type->sync_managers[i];

   242

        field_offset = 0;

   243

        for (j = 0; sync->fields[j]; j++) {

   244

            field = sync->fields[j];

   245

            if (field->type == field_type) {

   246

                if (field_idx == field_index) {

   247

                    ec_domain_reg_field(domain, slave, sync, field_offset,

   248

                                        data_ptr++);

   249

                    if (!(--field_count)) return slave;

   250

                }

   251

                field_idx++;

   252

            }

   253

            field_offset += field->size;

   254

        }

   255

    }

   256

   257

    EC_ERR("Slave %i (\"%s %s\") registration mismatch: Type %i, index %i,"

   258

           " count %i.\n", slave->ring_position, vendor_name, product_name,

   259

           field_type, field_index, field_count);

   260

    return NULL;

   261

}

   262

   263

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

   264

   265

/**

   267

   268

   \return 0 bei Erfolg, sonst < 0

   269

*/

   270

   271

int EtherCAT_rt_domain_xio(ec_domain_t *domain /**< Domäne */)

   272

{

   273

    unsigned int offset, size, working_counter_sum;

   274

    unsigned long start_ticks, end_ticks, timeout_ticks;

   275

    ec_master_t *master;

   276

    ec_frame_t *frame;

   277

   278

    master = domain->master;

   279

    frame = &domain->frame;

   280

    working_counter_sum = 0;

   281

   282

    ec_output_lost_frames(master); // Evtl. verlorene Frames ausgeben

   283

   284

    rdtscl(start_ticks); // Sendezeit nehmen

   285

    timeout_ticks = domain->timeout_us * cpu_khz / 1000;

   286

   287

    offset = 0;

   288

    while (offset < domain->data_size)

   289

    {

   290

        size = domain->data_size - offset;

   291

        if (size > EC_MAX_DATA_SIZE) size = EC_MAX_DATA_SIZE;

   292

   293

        ec_frame_init_lrw(frame, master, domain->base_address + offset, size,

   294

                          domain->data + offset);

   295

   296

        if (unlikely(ec_frame_send(frame) < 0)) {

   297

            EC_ERR("Could not send process data command!\n");

   298

            return -1;

   299

        }

   300

   301

        // Warten

   302

        do {

   303

            ec_device_call_isr(&master->device);

   304

            rdtscl(end_ticks); // Empfangszeit nehmen

   305

        }

   306

        while (unlikely(master->device.state == EC_DEVICE_STATE_SENT

   307

                        && end_ticks - start_ticks < timeout_ticks));

   308

   309

        master->bus_time = (end_ticks - start_ticks) * 1000 / cpu_khz;

   310

   311

        if (unlikely(end_ticks - start_ticks >= timeout_ticks)) {

   312

            master->device.state = EC_DEVICE_STATE_READY;

   313

            master->frames_lost++;

   314

            ec_output_lost_frames(master);

   315

            return -1;

   316

        }

   317

   318

        if (unlikely(ec_frame_receive(frame) < 0)) {

   319

            EC_ERR("Receiving process data failed!\n");

   320

            return -1;

   321

        }

   322

   323

        working_counter_sum += frame->working_counter;

   324

   325

        // Daten vom Rahmen in den Prozessdatenspeicher kopieren

   326

        memcpy(domain->data + offset, frame->data, size);

   327

   328

        offset += size;

   329

    }

   330

   331

    if (working_counter_sum != domain->response_count) {

   332

        domain->response_count = working_counter_sum;

   333

        EC_INFO("Domain %08X state change - %i slaves responding.\n",

   334

                (u32) domain, working_counter_sum);

   335

    }

   336

   337

    return 0;

   338

}

   339

   340

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

   341

   342

EXPORT_SYMBOL(EtherCAT_rt_register_slave_field);

   343

EXPORT_SYMBOL(EtherCAT_rt_domain_xio);

   344

   345

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

   346

   347

/* Emacs-Konfiguration

   348

;;; Local Variables: ***

   349

;;; c-basic-offset:4 ***

   350

;;; End: ***

   351

*/