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

    65

   \returns 0 bei Erfolg, < 0 bei Fehler

    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

/**

   102

    \returns 0 bei Erfolg, < 0 bei Fehler

   103

*/

   104

   105

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

   106

                    uint32_t base_address /**< Logische Basisadresse */

   107

                    )

   108

{

   109

    ec_field_reg_t *field_reg, *next;

   110

    ec_slave_t *slave;

   111

    ec_fmmu_t *fmmu;

   112

    unsigned int i, j, found, data_offset;

   113

   114

    if (domain->data) {

   115

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

   116

        return -1;

   117

    }

   118

   119

    domain->base_address = base_address;

   120

   121

    // Größe der Prozessdaten berechnen

   122

    // und logische Adressen der FMMUs setzen

   123

    domain->data_size = 0;

   124

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

   125

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

   126

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

   127

            fmmu = &slave->fmmus[j];

   128

            if (fmmu->domain == domain) {

   129

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

   130

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

   131

            }

   132

        }

   133

    }

   134

   135

    if (!domain->data_size) {

   136

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

   137

    }

   138

    else {

   139

        // Prozessdaten allozieren

   140

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

   141

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

   142

            return -1;

   143

        }

   144

   145

        // Prozessdaten mit Nullen vorbelegen

   146

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

   147

   148

        // Alle Prozessdatenzeiger setzen

   149

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

   150

            found = 0;

   151

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

   152

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

   153

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

   154

                    data_offset = fmmu->logical_start_address - base_address

   155

                        + field_reg->field_offset;

   156

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

   157

                    found = 1;

   158

                    break;

   159

                }

   160

            }

   161

   162

            if (!found) { // Sollte nie passieren

   163

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

   164

                return -1;

   165

            }

   166

        }

   167

    }

   168

   169

    // Registrierungsliste wird jetzt nicht mehr gebraucht.

   170

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

   171

        kfree(field_reg);

   172

    }

   173

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

   174

   175

    return 0;

   176

}

   177

   178

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

   179

 *

   180

 * Echtzeitschnittstelle

   181

 *

   182

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

   183

   184

/**

   185

   Registriert einer Domäne ein Datenfeld hinzu.

   186

   187

   \return Zeiger auf den Slave bei Erfolg, sonst NULL

   188

*/

   189

   190

ec_slave_t *EtherCAT_rt_register_slave_field(

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

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

   198

                                 \a field_type gezählt werden soll. */

   199

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

   200

    )

   201

{

   202

    ec_slave_t *slave;

   203

    const ec_slave_type_t *type;

   204

    ec_master_t *master;

   205

    const ec_sync_t *sync;

   206

    const ec_field_t *field;

   207

    unsigned int field_idx, i, j;

   208

    uint32_t field_offset;

   209

   210

    if (!field_count) {

   211

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

   212

        return NULL;

   213

    }

   214

   215

    master = domain->master;

   216

   217

    // Adresse übersetzen

   218

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

   219

   220

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

   221

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

   222

               slave->ring_position);

   223

        return NULL;

   224

    }

   225

   226

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

   227

        strcmp(product_name, type->product_name)) {

   228

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

   229

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

   230

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

   231

        return NULL;

   232

    }

   233

   234

    field_idx = 0;

   235

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

   236

        sync = type->sync_managers[i];

   237

        field_offset = 0;

   238

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

   239

            field = sync->fields[j];

   240

            if (field->type == field_type) {

   241

                if (field_idx == field_index) {

   242

                    ec_domain_reg_field(domain, slave, sync, field_offset,

   243

                                        data_ptr++);

   244

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

   245

                }

   246

                field_idx++;

   247

            }

   248

            field_offset += field->size;

   249

        }

   250

    }

   251

   252

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

   253

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

   254

           field_type, field_index, field_count);

   255

    return NULL;

   256

}

   257

   258

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

   259

   260

/**

   261

   Sendet und empfängt Prozessdaten der angegebenen Domäne

   262

   263

   \return 0 bei Erfolg, sonst < 0

   264

*/

   265

   266

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

   267

{

   268

    unsigned int offset, size, working_counter_sum;

   269

    unsigned long start_ticks, end_ticks, timeout_ticks;

   270

    ec_master_t *master;

   271

    ec_frame_t *frame;

   272

   273

    master = domain->master;

   274

    frame = &domain->frame;

   275

    working_counter_sum = 0;

   276

   277

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

   278

   279

    rdtscl(start_ticks); // Sendezeit nehmen

   280

    timeout_ticks = domain->timeout_us * cpu_khz / 1000;

   281

   282

    offset = 0;

   283

    while (offset < domain->data_size)

   284

    {

   285

        size = domain->data_size - offset;

   286

        if (size > EC_MAX_DATA_SIZE) size = EC_MAX_DATA_SIZE;

   287

   288

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

   289

                          domain->data + offset);

   290

   291

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

   292

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

   293

            return -1;

   294

        }

   295

   296

        // Warten

   297

        do {

   298

            ec_device_call_isr(&master->device);

   299

            rdtscl(end_ticks); // Empfangszeit nehmen

   300

        }

   301

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

   302

                        && end_ticks - start_ticks < timeout_ticks));

   303

   304

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

   305

   306

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

   307

            master->device.state = EC_DEVICE_STATE_READY;

   308

            master->frames_lost++;

   309

            ec_output_lost_frames(master);

   310

            return -1;

   311

        }

   312

   313

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

   314

            EC_ERR("Receive error!\n");

   315

            return -1;

   316

        }

   317

   318

        if (unlikely(frame->state != ec_frame_received)) {

   319

            EC_WARN("Process data command not received!\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

*/