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

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

    53

    54

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

    55

    56

/** \cond */

    57

    58

EC_SYSFS_READ_ATTR(image_size);

    59

    60

static struct attribute *def_attrs[] = {

    61

    &attr_image_size,

    62

    NULL,

    63

};

    64

    65

static struct sysfs_ops sysfs_ops = {

    66

    .show = &ec_show_domain_attribute,

    67

    .store = NULL

    68

};

    69

    70

static struct kobj_type ktype_ec_domain = {

    71

    .release = ec_domain_clear,

    72

    .sysfs_ops = &sysfs_ops,

    73

    .default_attrs = def_attrs

    74

};

    75

    76

/** \endcond */

    77

    78

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

    79

    80

/** Domain constructor.

    81

 *

    82

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

    83

 */

    84

int ec_domain_init(

    85

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

    86

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

    87

        unsigned int index /**< Index. */

    88

        )

    89

{

    90

    domain->master = master;

    91

    domain->index = index;

    92

    domain->data_size = 0;

    93

    domain->base_address = 0;

    94

    domain->working_counter = 0xFFFFFFFF;

    95

    domain->notify_jiffies = 0;

    96

    domain->working_counter_changes = 0;

    97

    98

    INIT_LIST_HEAD(&domain->datagrams);

    99

   100

    // init kobject and add it to the hierarchy

   101

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

   102

    kobject_init(&domain->kobj);

   103

    domain->kobj.ktype = &ktype_ec_domain;

   104

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

   105

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

   106

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

   107

        kobject_put(&domain->kobj);

   108

        return -1;

   109

    }

   110

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

   111

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

   112

        kobject_put(&domain->kobj);

   113

        return -1;

   114

    }

   115

   116

    return 0;

   117

}

   118

   119

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

   120

   121

/**

   122

   Domain destructor.

   123

   Clears and frees a domain object.

   124

*/

   125

   126

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

   127

{

   128

    ec_datagram_t *datagram;

   129

   130

    // dequeue datagrams

   131

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

   132

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

   133

            list_del_init(&datagram->queue);

   134

    }

   135

   136

    // destroy self

   137

    kobject_del(&domain->kobj);

   138

    kobject_put(&domain->kobj);

   139

}

   140

   141

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

   142

   143

/**

   144

   Clear and free domain.

   145

   This method is called by the kobject,

   146

   once there are no more references to it.

   147

*/

   148

   149

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

   150

{

   151

    ec_domain_t *domain;

   152

    ec_datagram_t *datagram, *next;

   153

   154

    domain = container_of(kobj, ec_domain_t, kobj);

   155

   156

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

   157

        ec_datagram_clear(datagram);

   158

        kfree(datagram);

   159

    }

   160

   161

    kfree(domain);

   162

}

   163

   164

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

   165

   166

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

   167

 *

   168

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

   169

 */

   170

int ec_domain_add_datagram(

   171

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

   172

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

   173

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

   174

        )

   175

{

   176

    ec_datagram_t *datagram;

   177

   178

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

   179

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

   180

        return -1;

   181

    }

   182

   183

    ec_datagram_init(datagram);

   184

    snprintf(datagram->name, EC_DATAGRAM_NAME_SIZE,

   185

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

   186

   187

    if (ec_datagram_lrw(datagram, offset, data_size)) {

   188

        kfree(datagram);

   189

        return -1;

   190

    }

   191

   192

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

   193

    return 0;

   194

}

   195

   196

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

   197

   198

/** Finishes a domain.

   199

 *

   200

 * This allocates the necessary datagrams and writes the correct logical

   201

 * addresses to every configured FMMU.

   202

 *

   203

 * \retval 0 in case of success

   204

 * \retval <0 on failure.

   205

 */

   206

int ec_domain_finish(

   207

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

   208

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

   209

        )

   210

{

   211

    uint32_t datagram_offset;

   212

    size_t datagram_data_size;

   213

    unsigned int datagram_count, i;

   214

    ec_slave_config_t *sc;

   215

    ec_fmmu_config_t *fmmu;

   216

   217

    domain->base_address = base_address;

   218

   219

    // Cycle through all domain FMMUS, add the logical base address and assign

   220

    // as many PDO entries as possible to the datagrams.

   221

    datagram_offset = base_address;

   222

    datagram_data_size = 0;

   223

    datagram_count = 0;

   224

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

   225

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

   226

            fmmu = &sc->fmmu_configs[i];

   227

            if (fmmu->domain != domain)

   228

                continue;

   229

   230

            fmmu->logical_start_address += base_address;

   231

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

   232

                if (ec_domain_add_datagram(domain, datagram_offset,

   233

                            datagram_data_size)) return -1;

   234

                datagram_offset += datagram_data_size;

   235

                datagram_data_size = 0;

   236

                datagram_count++;

   237

            }

   238

            datagram_data_size += fmmu->data_size;

   239

        }

   240

    }

   241

   242

    // allocate last datagram

   243

    if (datagram_data_size) {

   244

        if (ec_domain_add_datagram(domain, datagram_offset,

   245

                                   datagram_data_size))

   246

            return -1;

   247

        datagram_count++;

   248

    }

   249

   250

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

   251

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

   252

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

   253

    return 0;

   254

}

   255

   256

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

   257

   258

/**

   259

   Formats attribute data for SysFS reading.

   260

   \return number of bytes to read

   261

*/

   262

   263

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

   264

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

   265

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

   266

                                 )

   267

{

   268

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

   269

   270

    if (attr == &attr_image_size) {

   271

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

   272

    }

   273

   274

    return 0;

   275

}

   276

   277

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

   278

 *  Realtime interface

   279

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

   280

   281

int ecrt_domain_reg_pdo_entry(ec_domain_t *domain, ec_slave_config_t *sc,

   282

        uint16_t index, uint8_t subindex)

   283

{

   284

    return ec_slave_config_reg_pdo_entry(sc, domain, index, subindex);

   285

}

   286

   287

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

   288

   289

int ecrt_domain_reg_pdo_entry_list(ec_domain_t *domain,

   290

        const ec_pdo_entry_reg_t *regs)

   291

{

   292

    const ec_pdo_entry_reg_t *reg;

   293

    ec_slave_config_t *sc;

   294

    int ret;

   295

   296

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

   297

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

   298

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

   299

            return -1;

   300

   301

        if ((ret = ecrt_domain_reg_pdo_entry(domain, sc, reg->index,

   302

                        reg->subindex)) < 0)

   303

            return -1;

   304

   305

        *reg->offset = ret;

   306

    }

   307

   308

    return 0;

   309

}

   310

   311

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

   312

   313

void ecrt_domain_process(ec_domain_t *domain)

   314

{

   315

    unsigned int working_counter_sum;

   316

    ec_datagram_t *datagram;

   317

   318

    working_counter_sum = 0;

   319

    domain->state = 0;

   320

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

   321

        ec_datagram_output_stats(datagram);

   322

        if (datagram->state == EC_DATAGRAM_RECEIVED) {

   323

            working_counter_sum += datagram->working_counter;

   324

        }

   325

        else {

   326

            domain->state = -1;

   327

        }

   328

    }

   329

   330

    if (working_counter_sum != domain->working_counter) {

   331

        domain->working_counter_changes++;

   332

        domain->working_counter = working_counter_sum;

   333

    }

   334

   335

    if (domain->working_counter_changes &&

   336

        jiffies - domain->notify_jiffies > HZ) {

   337

        domain->notify_jiffies = jiffies;

   338

        if (domain->working_counter_changes == 1) {

   339

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

   340

                    domain->working_counter);

   341

        }

   342

        else {

   343

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

   344

                    domain->index, domain->working_counter_changes,

   345

                    domain->working_counter);

   346

        }

   347

        domain->working_counter_changes = 0;

   348

    }

   349

}

   350

   351

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

   352

   353

void ecrt_domain_queue(ec_domain_t *domain)

   354

{

   355

    ec_datagram_t *datagram;

   356

   357

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

   358

        ec_master_queue_datagram(domain->master, datagram);

   359

    }

   360

}

   361

   362

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

   363

   364

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

   365

{

   366

    state->working_counter = domain->working_counter;

   367

    state->wc_state = EC_WC_ZERO; // FIXME

   368

}

   369

   370

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

   371

   372

/** \cond */

   373

   374

EXPORT_SYMBOL(ecrt_domain_reg_pdo_entry);

   375

EXPORT_SYMBOL(ecrt_domain_reg_pdo_entry_list);

   376

//EXPORT_SYMBOL(ecrt_domain_size);

   377

//EXPORT_SYMBOL(ecrt_domain_memory);

   378

EXPORT_SYMBOL(ecrt_domain_process);

   379

EXPORT_SYMBOL(ecrt_domain_queue);

   380

EXPORT_SYMBOL(ecrt_domain_state);

   381

   382

/** \endcond */

   383

   384

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