1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    15

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

 *  You should have received a copy of the GNU General Public License

    20

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    21

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT domain methods.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

    43

#include "globals.h"

    44

#include "master.h"

    45

#include "slave_config.h"

    46

    47

#include "domain.h"

    48

    49

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

    50

    51

void ec_domain_clear(struct kobject *);

    52

void ec_domain_clear_data(ec_domain_t *);

    53

ssize_t ec_show_domain_attribute(struct kobject *, struct attribute *, char *);

    54

    55

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

    56

    57

/** \cond */

    58

    59

EC_SYSFS_READ_ATTR(image_size);

    60

    61

static struct attribute *def_attrs[] = {

    62

    &attr_image_size,

    63

    NULL,

    64

};

    65

    66

static struct sysfs_ops sysfs_ops = {

    67

    .show = &ec_show_domain_attribute,

    68

    .store = NULL

    69

};

    70

    71

static struct kobj_type ktype_ec_domain = {

    72

    .release = ec_domain_clear,

    73

    .sysfs_ops = &sysfs_ops,

    74

    .default_attrs = def_attrs

    75

};

    76

    77

/** \endcond */

    78

    79

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

    80

    81

/** Domain constructor.

    82

 *

    83

 * \return 0 in case of success, else < 0

    84

 */

    85

int ec_domain_init(

    86

        ec_domain_t *domain, /**< EtherCAT domain. */

    87

        ec_master_t *master, /**< Parent master. */

    88

        unsigned int index /**< Index. */

    89

        )

    90

{

    91

    domain->master = master;

    92

    domain->index = index;

    93

    INIT_LIST_HEAD(&domain->fmmu_configs);

    94

    domain->data_size = 0;

    95

    domain->data = NULL;

    96

    domain->data_origin = EC_ORIG_INTERNAL;

    97

    domain->logical_base_address = 0x00000000;

    98

    INIT_LIST_HEAD(&domain->datagrams);

    99

    domain->working_counter = 0xFFFF;

   100

    domain->expected_working_counter = 0x0000;

   101

    domain->working_counter_changes = 0;

   102

    domain->notify_jiffies = 0;

   103

   104

    // init kobject and add it to the hierarchy

   105

    memset(&domain->kobj, 0x00, sizeof(struct kobject));

   106

    kobject_init(&domain->kobj);

   107

    domain->kobj.ktype = &ktype_ec_domain;

   108

    domain->kobj.parent = &master->kobj;

   109

    if (kobject_set_name(&domain->kobj, "domain%u", index)) {

   110

        EC_ERR("Failed to set kobj name.\n");

   111

        kobject_put(&domain->kobj);

   112

        return -1;

   113

    }

   114

    if (kobject_add(&domain->kobj)) {

   115

        EC_ERR("Failed to add domain kobject.\n");

   116

        kobject_put(&domain->kobj);

   117

        return -1;

   118

    }

   119

   120

    return 0;

   121

}

   122

   123

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

   124

   125

/** Domain destructor.

   126

 *

   127

 * Clears and frees a domain object.

   128

 */

   129

void ec_domain_destroy(ec_domain_t *domain /**< EtherCAT domain */)

   130

{

   131

    ec_datagram_t *datagram;

   132

   133

    // dequeue datagrams

   134

    list_for_each_entry(datagram, &domain->datagrams, list) {

   135

        if (!list_empty(&datagram->queue)) // datagram queued?

   136

            list_del_init(&datagram->queue);

   137

    }

   138

   139

    // destroy self

   140

    kobject_del(&domain->kobj);

   141

    kobject_put(&domain->kobj);

   142

}

   143

   144

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

   145

   146

/** Clear and free domain.

   147

 *

   148

 * This method is called by the kobject, once there are no more references

   149

 * to it.

   150

 */

   151

void ec_domain_clear(struct kobject *kobj /**< kobject of the domain */)

   152

{

   153

    ec_domain_t *domain;

   154

    ec_datagram_t *datagram, *next;

   155

   156

    domain = container_of(kobj, ec_domain_t, kobj);

   157

   158

    list_for_each_entry_safe(datagram, next, &domain->datagrams, list) {

   159

        ec_datagram_clear(datagram);

   160

        kfree(datagram);

   161

    }

   162

   163

    ec_domain_clear_data(domain);

   164

   165

    kfree(domain);

   166

}

   167

   168

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

   169

   170

/** Frees internally allocated memory.

   171

 */

   172

void ec_domain_clear_data(

   173

        ec_domain_t *domain /**< EtherCAT domain. */

   174

        )

   175

{

   176

    if (domain->data_origin == EC_ORIG_INTERNAL && domain->data)

   177

        kfree(domain->data);

   178

    domain->data = NULL;

   179

    domain->data_origin = EC_ORIG_INTERNAL;

   180

}

   181

   182

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

   183

   184

/** Adds an FMMU configuration to the domain.

   185

 */

   186

void ec_domain_add_fmmu_config(

   187

        ec_domain_t *domain, /**< EtherCAT domain. */

   188

        ec_fmmu_config_t *fmmu /**< FMMU configuration. */

   189

        )

   190

{

   191

    fmmu->domain = domain;

   192

   193

    domain->data_size += fmmu->data_size;

   194

    list_add_tail(&fmmu->list, &domain->fmmu_configs);

   195

   196

    if (domain->master->debug_level)

   197

        EC_DBG("Domain %u: Added %u bytes, total %u.\n", domain->index,

   198

                fmmu->data_size, domain->data_size);

   199

}

   200

   201

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

   202

   203

/** Allocates a domain datagram and appends it to the list.

   204

 *

   205

 * The datagram type and expected working counters are determined by the

   206

 * number of input and output fmmus that share the datagram.

   207

 *

   208

 * \return 0 in case of success, else < 0

   209

 */

   210

int ec_domain_add_datagram(

   211

        ec_domain_t *domain, /**< EtherCAT domain. */

   212

        uint32_t logical_offset, /**< Logical offset. */

   213

        size_t data_size, /**< Size of the data. */

   214

        uint8_t *data, /**< Process data. */

   215

        const unsigned int used[] /**< Used by inputs/outputs. */

   216

        )

   217

{

   218

    ec_datagram_t *datagram;

   219

   220

    if (!(datagram = kmalloc(sizeof(ec_datagram_t), GFP_KERNEL))) {

   221

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

   222

        return -1;

   223

    }

   224

   225

    ec_datagram_init(datagram);

   226

    snprintf(datagram->name, EC_DATAGRAM_NAME_SIZE,

   227

            "domain%u-%u", domain->index, logical_offset);

   228

   229

    if (used[EC_DIR_OUTPUT] && used[EC_DIR_INPUT]) { // inputs and outputs

   230

        if (ec_datagram_lrw(datagram, logical_offset, data_size, data)) {

   231

            kfree(datagram);

   232

            return -1;

   233

        }

   234

        // If LRW is used, output FMMUs increment the working counter by 2,

   235

        // while input FMMUs increment it by 1.

   236

        domain->expected_working_counter =

   237

            used[EC_DIR_OUTPUT] * 2 + used[EC_DIR_INPUT];

   238

    } else if (used[EC_DIR_OUTPUT]) { // outputs only

   239

        if (ec_datagram_lwr(datagram, logical_offset, data_size, data)) {

   240

            kfree(datagram);

   241

            return -1;

   242

        }

   243

        domain->expected_working_counter = used[EC_DIR_OUTPUT];

   244

    } else { // inputs only (or nothing)

   245

        if (ec_datagram_lrd(datagram, logical_offset, data_size, data)) {

   246

            kfree(datagram);

   247

            return -1;

   248

        }

   249

        domain->expected_working_counter = used[EC_DIR_INPUT];

   250

    }

   251

   252

    list_add_tail(&datagram->list, &domain->datagrams);

   253

    return 0;

   254

}

   255

   256

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

   257

   258

/** Finishes a domain.

   259

 *

   260

 * This allocates the necessary datagrams and writes the correct logical

   261

 * addresses to every configured FMMU.

   262

 *

   263

 * \todo Check for FMMUs that do not fit into any datagram.

   264

 *

   265

 * \retval 0 in case of success

   266

 * \retval <0 on failure.

   267

 */

   268

int ec_domain_finish(

   269

        ec_domain_t *domain, /**< EtherCAT domain. */

   270

        uint32_t base_address /**< Logical base address. */

   271

        )

   272

{

   273

    uint32_t datagram_offset;

   274

    size_t datagram_size;

   275

    unsigned int datagram_count;

   276

    unsigned int datagram_used[2];

   277

    ec_fmmu_config_t *fmmu;

   278

    const ec_datagram_t *datagram;

   279

   280

    domain->logical_base_address = base_address;

   281

   282

    if (domain->data_size && domain->data_origin == EC_ORIG_INTERNAL) {

   283

        if (!(domain->data =

   284

                    (uint8_t *) kmalloc(domain->data_size, GFP_KERNEL))) {

   285

            EC_ERR("Failed to allocate %u bytes internal memory for"

   286

                    " domain %u!\n", domain->data_size, domain->index);

   287

            return -1;

   288

        }

   289

    }

   290

   291

    // Cycle through all domain FMMUS and

   292

    // - correct the logical base addresses

   293

    // - set up the datagrams to carry the process data

   294

    datagram_offset = 0;

   295

    datagram_size = 0;

   296

    datagram_count = 0;

   297

    datagram_used[EC_DIR_OUTPUT] = 0;

   298

    datagram_used[EC_DIR_INPUT] = 0;

   299

   300

    list_for_each_entry(fmmu, &domain->fmmu_configs, list) {

   301

        // Correct logical FMMU address

   302

        fmmu->logical_start_address += base_address;

   303

   304

        // Increment Input/Output counter to determine datagram types

   305

        // and calculate expected working counters

   306

        datagram_used[fmmu->dir]++;

   307

   308

        // If the current FMMU's data do not fit in the current datagram,

   309

        // allocate a new one.

   310

        if (datagram_size + fmmu->data_size > EC_MAX_DATA_SIZE) {

   311

            if (ec_domain_add_datagram(domain,

   312

                        domain->logical_base_address + datagram_offset,

   313

                        datagram_size, domain->data + datagram_offset,

   314

                        datagram_used))

   315

                return -1;

   316

            datagram_offset += datagram_size;

   317

            datagram_size = 0;

   318

            datagram_count++;

   319

            datagram_used[EC_DIR_OUTPUT] = 0;

   320

            datagram_used[EC_DIR_INPUT] = 0;

   321

        }

   322

   323

        datagram_size += fmmu->data_size;

   324

    }

   325

   326

    // allocate last datagram, if data are left

   327

    if (datagram_size) {

   328

        if (ec_domain_add_datagram(domain,

   329

                    domain->logical_base_address + datagram_offset,

   330

                    datagram_size, domain->data + datagram_offset,

   331

                    datagram_used))

   332

            return -1;

   333

        datagram_count++;

   334

    }

   335

   336

    EC_INFO("Domain%u: Logical address 0x%08x, %u byte, "

   337

            "expected working counter %u.\n", domain->index,

   338

            domain->logical_base_address, domain->data_size,

   339

            domain->expected_working_counter);

   340

    list_for_each_entry(datagram, &domain->datagrams, list) {

   341

        EC_INFO("  Datagram %s: Logical offset 0x%08x, %u byte, type %s.\n",

   342

                datagram->name, EC_READ_U32(datagram->address),

   343

                datagram->data_size, ec_datagram_type_string(datagram));

   344

    }

   345

   346

    return 0;

   347

}

   348

   349

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

   350

   351

/**

   352

   Formats attribute data for SysFS reading.

   353

   \return number of bytes to read

   354

*/

   355

   356

ssize_t ec_show_domain_attribute(struct kobject *kobj, /**< kobject */

   357

                                 struct attribute *attr, /**< attribute */

   358

                                 char *buffer /**< memory to store data in */

   359

                                 )

   360

{

   361

    ec_domain_t *domain = container_of(kobj, ec_domain_t, kobj);

   362

   363

    if (attr == &attr_image_size) {

   364

        return sprintf(buffer, "%u\n", domain->data_size);

   365

    }

   366

   367

    return 0;

   368

}

   369

   370

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

   371

   372

unsigned int ec_domain_fmmu_count(const ec_domain_t *domain)

   373

{

   374

    const ec_fmmu_config_t *fmmu;

   375

    unsigned int num = 0;

   376

   377

    list_for_each_entry(fmmu, &domain->fmmu_configs, list) {

   378

        num++;

   379

    }

   380

   381

    return num;

   382

}

   383

   384

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

   385

   386

const ec_fmmu_config_t *ec_domain_find_fmmu(

   387

        const ec_domain_t *domain,

   388

        unsigned int index

   389

        )

   390

{

   391

    const ec_fmmu_config_t *fmmu;

   392

   393

    list_for_each_entry(fmmu, &domain->fmmu_configs, list) {

   394

        if (index--)

   395

            continue;

   396

        return fmmu;

   397

    }

   398

   399

    return NULL;

   400

}

   401

   402

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

   403

 *  Realtime interface

   404

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

   405

   406

int ecrt_domain_reg_pdo_entry_list(ec_domain_t *domain,

   407

        const ec_pdo_entry_reg_t *regs)

   408

{

   409

    const ec_pdo_entry_reg_t *reg;

   410

    ec_slave_config_t *sc;

   411

    int ret;

   412

   413

    for (reg = regs; reg->index; reg++) {

   414

        if (!(sc = ecrt_master_slave_config(domain->master, reg->alias,

   415

                        reg->position, reg->vendor_id, reg->product_code)))

   416

            return -1;

   417

   418

        if ((ret = ecrt_slave_config_reg_pdo_entry(sc, reg->index,

   419

                        reg->subindex, domain, reg->bit_position)) < 0)

   420

            return -1;

   421

   422

        *reg->offset = ret;

   423

    }

   424

   425

    return 0;

   426

}

   427

   428

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

   429

   430

size_t ecrt_domain_size(ec_domain_t *domain)

   431

{

   432

    return domain->data_size;

   433

}

   434

   435

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

   436

   437

void ecrt_domain_external_memory(ec_domain_t *domain, uint8_t *mem)

   438

{

   439

    ec_domain_clear_data(domain);

   440

   441

    domain->data = mem;

   442

    domain->data_origin = EC_ORIG_EXTERNAL;

   443

}

   444

   445

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

   446

   447

uint8_t *ecrt_domain_data(ec_domain_t *domain)

   448

{

   449

    return domain->data;

   450

}

   451

   452

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

   453

   454

void ecrt_domain_process(ec_domain_t *domain)

   455

{

   456

    uint16_t working_counter_sum;

   457

    ec_datagram_t *datagram;

   458

   459

    working_counter_sum = 0x0000;

   460

    list_for_each_entry(datagram, &domain->datagrams, list) {

   461

        ec_datagram_output_stats(datagram);

   462

        if (datagram->state == EC_DATAGRAM_RECEIVED) {

   463

            working_counter_sum += datagram->working_counter;

   464

        }

   465

    }

   466

   467

    if (working_counter_sum != domain->working_counter) {

   468

        domain->working_counter_changes++;

   469

        domain->working_counter = working_counter_sum;

   470

    }

   471

   472

    if (domain->working_counter_changes &&

   473

        jiffies - domain->notify_jiffies > HZ) {

   474

        domain->notify_jiffies = jiffies;

   475

        if (domain->working_counter_changes == 1) {

   476

            EC_INFO("Domain %u: Working counter changed to %u/%u.\n",

   477

                    domain->index, domain->working_counter,

   478

                    domain->expected_working_counter);

   479

        } else {

   480

            EC_INFO("Domain %u: %u working counter changes. Currently %u/%u.\n",

   481

                    domain->index, domain->working_counter_changes,

   482

                    domain->working_counter, domain->expected_working_counter);

   483

        }

   484

        domain->working_counter_changes = 0;

   485

    }

   486

}

   487