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

    domain->data_size = 0;

    94

    domain->data = NULL;

    95

    domain->data_origin = EC_ORIG_INTERNAL;

    96

    domain->logical_base_address = 0L;

    97

    domain->working_counter = 0xFFFFFFFF;

    98

    domain->notify_jiffies = 0;

    99

    domain->working_counter_changes = 0;

   100

   101

    INIT_LIST_HEAD(&domain->datagrams);

   102

   103

    // init kobject and add it to the hierarchy

   104

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

   105

    kobject_init(&domain->kobj);

   106

    domain->kobj.ktype = &ktype_ec_domain;

   107

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

   108

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

   109

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

   110

        kobject_put(&domain->kobj);

   111

        return -1;

   112

    }

   113

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

   114

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

   115

        kobject_put(&domain->kobj);

   116

        return -1;

   117

    }

   118

   119

    return 0;

   120

}

   121

   122

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

   123

   124

/**

   125

   Domain destructor.

   126

   Clears and frees a domain object.

   127

*/

   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

/**

   147

   Clear and free domain.

   148

   This method is called by the kobject,

   149

   once there are no more references to it.

   150

*/

   151

   152

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

   153

{

   154

    ec_domain_t *domain;

   155

    ec_datagram_t *datagram, *next;

   156

   157

    domain = container_of(kobj, ec_domain_t, kobj);

   158

   159

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

   160

        ec_datagram_clear(datagram);

   161

        kfree(datagram);

   162

    }

   163

   164

    ec_domain_clear_data(domain);

   165

   166

    kfree(domain);

   167

}

   168

   169

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

   170

   171

/** Frees internally allocated memory.

   172

 */

   173

void ec_domain_clear_data(

   174

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

   175

        )

   176

{

   177

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

   178

        kfree(domain->data);

   179

    domain->data = NULL;

   180

    domain->data_origin = EC_ORIG_INTERNAL;

   181

}

   182

   183

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

   184

   185

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

   186

 *

   187

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

   188

 */

   189

int ec_domain_add_datagram(

   190

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

   191

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

   192

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

   193

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

   194

        )

   195

{

   196

    ec_datagram_t *datagram;

   197

   198

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

   199

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

   200

        return -1;

   201

    }

   202

   203

    ec_datagram_init(datagram);

   204

    snprintf(datagram->name, EC_DATAGRAM_NAME_SIZE,

   205

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

   206

   207

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

   208

        kfree(datagram);

   209

        return -1;

   210

    }

   211

   212

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

   213

    return 0;

   214

}

   215

   216

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

   217

   218

/** Finishes a domain.

   219

 *

   220

 * This allocates the necessary datagrams and writes the correct logical

   221

 * addresses to every configured FMMU.

   222

 *

   223

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

   224

 *

   225

 * \retval 0 in case of success

   226

 * \retval <0 on failure.

   227

 */

   228

int ec_domain_finish(

   229

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

   230

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

   231

        )

   232

{

   233

    uint32_t datagram_offset;

   234

    size_t datagram_size;

   235

    unsigned int datagram_count, i;

   236

    ec_slave_config_t *sc;

   237

    ec_fmmu_config_t *fmmu;

   238

   239

    domain->logical_base_address = base_address;

   240

   241

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

   242

        if (!(domain->data =

   243

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

   244

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

   245

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

   246

            return -1;

   247

        }

   248

    }

   249

   250

    // Cycle through all domain FMMUS, correct the logical base addresses and

   251

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

   252

    datagram_offset = 0;

   253

    datagram_size = 0;

   254

    datagram_count = 0;

   255

    list_for_each_entry(sc, &domain->master->configs, list) {

   256

        for (i = 0; i < sc->used_fmmus; i++) {

   257

            fmmu = &sc->fmmu_configs[i];

   258

            if (fmmu->domain != domain)

   259

                continue;

   260

   261

            // Correct logical FMMU address

   262

            fmmu->logical_start_address += base_address;

   263

   264

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

   265

            // allocate a new one.

   266

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

   267

                if (ec_domain_add_datagram(domain,

   268

                            domain->logical_base_address + datagram_offset,

   269

                            datagram_size, domain->data + datagram_offset))

   270

                    return -1;

   271

                datagram_offset += datagram_size;

   272

                datagram_size = 0;

   273

                datagram_count++;

   274

            }

   275

   276

            datagram_size += fmmu->data_size;

   277

        }

   278

    }

   279

   280

    // allocate last datagram, if data are left

   281

    if (datagram_size) {

   282

        if (ec_domain_add_datagram(domain,

   283

                    domain->logical_base_address + datagram_offset,

   284

                    datagram_size, domain->data + datagram_offset))

   285

            return -1;

   286

        datagram_count++;

   287

    }

   288

   289

    EC_INFO("Domain %u with logical offset %u contains %u bytes in %u"

   290

            " datagram%s.\n", domain->index, domain->logical_base_address,

   291

            domain->data_size, datagram_count, datagram_count == 1 ? "" : "s");

   292

    return 0;

   293

}

   294

   295

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

   296

   297

/**

   298

   Formats attribute data for SysFS reading.

   299

   \return number of bytes to read

   300

*/

   301

   302

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

   303

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

   304

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

   305

                                 )

   306

{

   307

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

   308

   309

    if (attr == &attr_image_size) {

   310

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

   311

    }

   312

   313

    return 0;

   314

}

   315

   316

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

   317

 *  Realtime interface

   318

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

   319

   320

int ecrt_domain_reg_pdo_entry_list(ec_domain_t *domain,

   321

        const ec_pdo_entry_reg_t *regs)

   322

{

   323

    const ec_pdo_entry_reg_t *reg;

   324

    ec_slave_config_t *sc;

   325

    int ret;

   326

   327

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

   328

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

   329

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

   330

            return -1;

   331

   332

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

   333

                        reg->subindex, domain)) < 0)

   334

            return -1;

   335

   336

        *reg->offset = ret;

   337

    }

   338

   339

    return 0;

   340

}

   341

   342

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

   343

   344

size_t ecrt_domain_size(ec_domain_t *domain)

   345

{

   346

    return domain->data_size;

   347

}

   348

   349

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

   350

   351

void ecrt_domain_external_memory(ec_domain_t *domain, uint8_t *mem)

   352

{

   353

    ec_domain_clear_data(domain);

   354

   355

    domain->data = mem;

   356

    domain->data_origin = EC_ORIG_EXTERNAL;

   357

}

   358

   359

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

   360

   361

uint8_t *ecrt_domain_data(ec_domain_t *domain)

   362

{

   363

    return domain->data;

   364

}

   365

   366

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

   367

   368

void ecrt_domain_process(ec_domain_t *domain)

   369

{

   370

    unsigned int working_counter_sum;

   371

    ec_datagram_t *datagram;

   372

   373

    working_counter_sum = 0;

   374

    domain->state = 0;

   375

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

   376

        ec_datagram_output_stats(datagram);

   377

        if (datagram->state == EC_DATAGRAM_RECEIVED) {

   378

            working_counter_sum += datagram->working_counter;

   379

        }

   380

        else {

   381

            domain->state = -1;

   382

        }

   383

    }

   384

   385

    if (working_counter_sum != domain->working_counter) {

   386

        domain->working_counter_changes++;

   387

        domain->working_counter = working_counter_sum;

   388

    }

   389

   390

    if (domain->working_counter_changes &&

   391

        jiffies - domain->notify_jiffies > HZ) {

   392

        domain->notify_jiffies = jiffies;

   393

        if (domain->working_counter_changes == 1) {

   394

            EC_INFO("Domain %u working counter change: %u\n", domain->index,

   395

                    domain->working_counter);

   396

        }

   397

        else {

   398

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

   399

                    domain->index, domain->working_counter_changes,

   400

                    domain->working_counter);

   401

        }

   402

        domain->working_counter_changes = 0;

   403

    }

   404

}

   405

   406

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

   407

   408

void ecrt_domain_queue(ec_domain_t *domain)

   409

{

   410

    ec_datagram_t *datagram;

   411

   412

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

   413

        ec_master_queue_datagram(domain->master, datagram);

   414

    }

   415

}

   416

   417

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

   418

   419

void ecrt_domain_state(const ec_domain_t *domain, ec_domain_state_t *state)

   420

{

   421

    state->working_counter = domain->working_counter;

   422

    state->wc_state = EC_WC_ZERO; // FIXME

   423

}

   424

   425

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

   426

   427

/** \cond */

   428

   429

EXPORT_SYMBOL(ecrt_domain_reg_pdo_entry_list);

   430

EXPORT_SYMBOL(ecrt_domain_size);

   431

EXPORT_SYMBOL(ecrt_domain_external_memory);

   432

EXPORT_SYMBOL(ecrt_domain_data);

   433

EXPORT_SYMBOL(ecrt_domain_process);

   434

EXPORT_SYMBOL(ecrt_domain_queue);

   435

EXPORT_SYMBOL(ecrt_domain_state);

   436

   437

/** \endcond */

   438

   439

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