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 slave methods.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

#include <linux/delay.h>

    43

    44

#include "globals.h"

    45

#include "slave.h"

    46

#include "datagram.h"

    47

#include "master.h"

    48

    49

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

    50

    51

extern const ec_code_msg_t al_status_messages[];

    52

    53

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

    54

    55

void ec_slave_clear(struct kobject *);

    56

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

    57

ssize_t ec_store_slave_attribute(struct kobject *, struct attribute *,

    58

                                 const char *, size_t);

    59

    60

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

    61

    62

/** \cond */

    63

    64

EC_SYSFS_READ_ATTR(info);

    65

EC_SYSFS_READ_WRITE_ATTR(state);

    66

EC_SYSFS_READ_WRITE_ATTR(eeprom);

    67

    68

static struct attribute *def_attrs[] = {

    69

    &attr_info,

    70

    &attr_state,

    71

    &attr_eeprom,

    72

    NULL,

    73

};

    74

    75

static struct sysfs_ops sysfs_ops = {

    76

    .show = ec_show_slave_attribute,

    77

    .store = ec_store_slave_attribute

    78

};

    79

    80

static struct kobj_type ktype_ec_slave = {

    81

    .release = ec_slave_clear,

    82

    .sysfs_ops = &sysfs_ops,

    83

    .default_attrs = def_attrs

    84

};

    85

    86

static struct kobj_type ktype_ec_slave_sdos = {};

    87

    88

/** \endcond */

    89

    90

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

    91

    92

/**

    93

   Slave constructor.

    94

   \return 0 in case of success, else < 0

    95

*/

    96

    97

int ec_slave_init(ec_slave_t *slave, /**< EtherCAT slave */

    98

                  ec_master_t *master, /**< EtherCAT master */

    99

                  uint16_t ring_position, /**< ring position */

   100

                  uint16_t station_address /**< station address to configure */

   101

                  )

   102

{

   103

    unsigned int i;

   104

   105

    slave->ring_position = ring_position;

   106

    slave->station_address = station_address;

   107

   108

    // init kobject and add it to the hierarchy

   109

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

   110

    kobject_init(&slave->kobj);

   111

    slave->kobj.ktype = &ktype_ec_slave;

   112

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

   113

    if (kobject_set_name(&slave->kobj, "slave%03i", slave->ring_position)) {

   114

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

   115

        kobject_put(&slave->kobj);

   116

        return -1;

   117

    }

   118

   119

    // init SDO kobject and add it to the hierarchy

   120

    memset(&slave->sdo_kobj, 0x00, sizeof(struct kobject));

   121

    kobject_init(&slave->sdo_kobj);

   122

    slave->sdo_kobj.ktype = &ktype_ec_slave_sdos;

   123

    slave->sdo_kobj.parent = &slave->kobj;

   124

    if (kobject_set_name(&slave->sdo_kobj, "sdos")) {

   125

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

   126

        kobject_put(&slave->sdo_kobj);

   127

        kobject_put(&slave->kobj);

   128

        return -1;

   129

    }

   130

   131

    slave->master = master;

   132

   133

    slave->requested_state = EC_SLAVE_STATE_UNKNOWN;

   134

    slave->current_state = EC_SLAVE_STATE_UNKNOWN;

   135

    slave->configured = 0;

   136

    slave->error_flag = 0;

   137

    slave->online = 1;

   138

    slave->fmmu_count = 0;

   139

    slave->registered = 0;

   140

   141

    slave->coupler_index = 0;

   142

    slave->coupler_subindex = 0xFFFF;

   143

   144

    slave->base_type = 0;

   145

    slave->base_revision = 0;

   146

    slave->base_build = 0;

   147

    slave->base_fmmu_count = 0;

   148

    slave->base_sync_count = 0;

   149

   150

    slave->eeprom_data = NULL;

   151

    slave->eeprom_size = 0;

   152

    slave->new_eeprom_data = NULL;

   153

    slave->new_eeprom_size = 0;

   154

   155

    slave->sii_alias = 0;

   156

    slave->sii_vendor_id = 0;

   157

    slave->sii_product_code = 0;

   158

    slave->sii_revision_number = 0;

   159

    slave->sii_serial_number = 0;

   160

    slave->sii_rx_mailbox_offset = 0;

   161

    slave->sii_rx_mailbox_size = 0;

   162

    slave->sii_tx_mailbox_offset = 0;

   163

    slave->sii_tx_mailbox_size = 0;

   164

    slave->sii_mailbox_protocols = 0;

   165

    slave->sii_group = NULL;

   166

    slave->sii_image = NULL;

   167

    slave->sii_order = NULL;

   168

    slave->sii_name = NULL;

   169

   170

    INIT_LIST_HEAD(&slave->sii_strings);

   171

    INIT_LIST_HEAD(&slave->sii_syncs);

   172

    INIT_LIST_HEAD(&slave->sii_pdos);

   173

    INIT_LIST_HEAD(&slave->sdo_dictionary);

   174

    INIT_LIST_HEAD(&slave->sdo_confs);

   175

   176

    slave->sdo_dictionary_fetched = 0;

   177

    slave->jiffies_preop = 0;

   178

   179

    for (i = 0; i < 4; i++) {

   180

        slave->dl_link[i] = 0;

   181

        slave->dl_loop[i] = 0;

   182

        slave->dl_signal[i] = 0;

   183

        slave->sii_physical_layer[i] = 0xFF;

   184

    }

   185

   186

    return 0;

   187

}

   188

   189

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

   190

   191

/**

   192

   Slave destructor.

   193

*/

   194

   195

void ec_slave_clear(struct kobject *kobj /**< kobject of the slave */)

   196

{

   197

    ec_slave_t *slave;

   198

    ec_sii_string_t *string, *next_str;

   199

    ec_sii_sync_t *sync, *next_sync;

   200

    ec_sii_pdo_t *pdo, *next_pdo;

   201

    ec_sii_pdo_entry_t *entry, *next_ent;

   202

    ec_sdo_t *sdo, *next_sdo;

   203

    ec_sdo_data_t *sdodata, *next_sdodata;

   204

   205

    slave = container_of(kobj, ec_slave_t, kobj);

   206

   207

    // free all string objects

   208

    list_for_each_entry_safe(string, next_str, &slave->sii_strings, list) {

   209

        list_del(&string->list);

   210

        kfree(string);

   211

    }

   212

   213

    // free all sync managers

   214

    list_for_each_entry_safe(sync, next_sync, &slave->sii_syncs, list) {

   215

        list_del(&sync->list);

   216

        kfree(sync);

   217

    }

   218

   219

    // free all PDOs

   220

    list_for_each_entry_safe(pdo, next_pdo, &slave->sii_pdos, list) {

   221

        list_del(&pdo->list);

   222

        if (pdo->name) kfree(pdo->name);

   223

   224

        // free all PDO entries

   225

        list_for_each_entry_safe(entry, next_ent, &pdo->entries, list) {

   226

            list_del(&entry->list);

   227

            if (entry->name) kfree(entry->name);

   228

            kfree(entry);

   229

        }

   230

   231

        kfree(pdo);

   232

    }

   233

   234

    if (slave->sii_group) kfree(slave->sii_group);

   235

    if (slave->sii_image) kfree(slave->sii_image);

   236

    if (slave->sii_order) kfree(slave->sii_order);

   237

    if (slave->sii_name) kfree(slave->sii_name);

   238

   239

    // free all SDOs

   240

    list_for_each_entry_safe(sdo, next_sdo, &slave->sdo_dictionary, list) {

   241

        list_del(&sdo->list);

   242

        kobject_del(&sdo->kobj);

   243

        kobject_put(&sdo->kobj);

   244

    }

   245

   246

    // free SDO kobject

   247

    if (slave->sdo_dictionary_fetched) kobject_del(&slave->sdo_kobj);

   248

    kobject_put(&slave->sdo_kobj);

   249

   250

    // free all SDO configurations

   251

    list_for_each_entry_safe(sdodata, next_sdodata, &slave->sdo_confs, list) {

   252

        list_del(&sdodata->list);

   253

        kfree(sdodata->data);

   254

        kfree(sdodata);

   255

    }

   256

   257

    if (slave->eeprom_data) kfree(slave->eeprom_data);

   258

    if (slave->new_eeprom_data) kfree(slave->new_eeprom_data);

   259

   260

    kfree(slave);

   261

}

   262

   263

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

   264

   265

/**

   266

   Fetches data from a STRING category.

   267

   \return 0 in case of success, else < 0

   268

*/

   269

   270

int ec_slave_fetch_strings(ec_slave_t *slave, /**< EtherCAT slave */

   271

                           const uint8_t *data /**< category data */

   272

                           )

   273

{

   274

    unsigned int string_count, i;

   275

    size_t size;

   276

    off_t offset;

   277

    ec_sii_string_t *string;

   278

   279

    string_count = data[0];

   280

    offset = 1;

   281

    for (i = 0; i < string_count; i++) {

   282

        size = data[offset];

   283

        // allocate memory for string structure and data at a single blow

   284

        if (!(string = (ec_sii_string_t *)

   285

              kmalloc(sizeof(ec_sii_string_t) + size + 1, GFP_ATOMIC))) {

   286

            EC_ERR("Failed to allocate string memory.\n");

   287

            return -1;

   288

        }

   289

        string->size = size;

   290

        // string memory appended to string structure

   291

        string->data = (char *) string + sizeof(ec_sii_string_t);

   292

        memcpy(string->data, data + offset + 1, size);

   293

        string->data[size] = 0x00;

   294

        list_add_tail(&string->list, &slave->sii_strings);

   295

        offset += 1 + size;

   296

    }

   297

   298

    return 0;

   299

}

   300

   301

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

   302

   303

/**

   304

   Fetches data from a GENERAL category.

   305

   \return 0 in case of success, else < 0

   306

*/

   307

   308

void ec_slave_fetch_general(ec_slave_t *slave, /**< EtherCAT slave */

   309

                            const uint8_t *data /**< category data */

   310

                            )

   311

{

   312

    unsigned int i;

   313

   314

    ec_slave_locate_string(slave, data[0], &slave->sii_group);

   315

    ec_slave_locate_string(slave, data[1], &slave->sii_image);

   316

    ec_slave_locate_string(slave, data[2], &slave->sii_order);

   317

    ec_slave_locate_string(slave, data[3], &slave->sii_name);

   318

   319

    for (i = 0; i < 4; i++)

   320

        slave->sii_physical_layer[i] =

   321

            (data[4] & (0x03 << (i * 2))) >> (i * 2);

   322

}

   323

   324

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

   325

   326

/**

   327

   Fetches data from a SYNC MANAGER category.

   328

   \return 0 in case of success, else < 0

   329

*/

   330

   331

int ec_slave_fetch_sync(ec_slave_t *slave, /**< EtherCAT slave */

   332

                        const uint8_t *data, /**< category data */

   333

                        size_t word_count /**< number of words */

   334

                        )

   335

{

   336

    unsigned int sync_count, i;

   337

    ec_sii_sync_t *sync;

   338

   339

    sync_count = word_count / 4; // sync manager struct is 4 words long

   340

   341

    for (i = 0; i < sync_count; i++, data += 8) {

   342

        if (!(sync = (ec_sii_sync_t *)

   343

              kmalloc(sizeof(ec_sii_sync_t), GFP_ATOMIC))) {

   344

            EC_ERR("Failed to allocate Sync-Manager memory.\n");

   345

            return -1;

   346

        }

   347

   348

        sync->index = i;

   349

        sync->physical_start_address = EC_READ_U16(data);

   350

        sync->length                 = EC_READ_U16(data + 2);

   351

        sync->control_register       = EC_READ_U8 (data + 4);

   352

        sync->enable                 = EC_READ_U8 (data + 6);

   353

   354

        sync->est_length = 0;

   355

   356

        list_add_tail(&sync->list, &slave->sii_syncs);

   357

    }

   358

   359

    return 0;

   360

}

   361

   362

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

   363

   364

/**

   365

   Fetches data from a [RT]XPDO category.

   366

   \return 0 in case of success, else < 0

   367

*/

   368

   369

int ec_slave_fetch_pdo(ec_slave_t *slave, /**< EtherCAT slave */

   370

                       const uint8_t *data, /**< category data */

   371

                       size_t word_count, /**< number of words */

   372

                       ec_sii_pdo_type_t pdo_type /**< PDO type */

   373

                       )

   374

{

   375

    ec_sii_pdo_t *pdo;

   376

    ec_sii_pdo_entry_t *entry;

   377

    unsigned int entry_count, i;

   378

   379

    while (word_count >= 4) {

   380

        if (!(pdo = (ec_sii_pdo_t *)

   381

              kmalloc(sizeof(ec_sii_pdo_t), GFP_ATOMIC))) {

   382

            EC_ERR("Failed to allocate PDO memory.\n");

   383

            return -1;

   384

        }

   385

   386

        INIT_LIST_HEAD(&pdo->entries);

   387

        pdo->type = pdo_type;

   388

   389

        pdo->index = EC_READ_U16(data);

   390

        entry_count = EC_READ_U8(data + 2);

   391

        pdo->sync_index = EC_READ_U8(data + 3);

   392

        pdo->name = NULL;

   393

        ec_slave_locate_string(slave, EC_READ_U8(data + 5), &pdo->name);

   394

   395

        list_add_tail(&pdo->list, &slave->sii_pdos);

   396

   397

        word_count -= 4;

   398

        data += 8;

   399

   400

        for (i = 0; i < entry_count; i++) {

   401

            if (!(entry = (ec_sii_pdo_entry_t *)

   402

                  kmalloc(sizeof(ec_sii_pdo_entry_t), GFP_ATOMIC))) {

   403

                EC_ERR("Failed to allocate PDO entry memory.\n");

   404

                return -1;

   405

            }

   406

   407

            entry->index = EC_READ_U16(data);

   408

            entry->subindex = EC_READ_U8(data + 2);

   409

            entry->name = NULL;

   410

            ec_slave_locate_string(slave, EC_READ_U8(data + 3), &entry->name);

   411

            entry->bit_length = EC_READ_U8(data + 5);

   412

   413

            list_add_tail(&entry->list, &pdo->entries);

   414

   415

            word_count -= 4;

   416

            data += 8;

   417

        }

   418

    }

   419

   420

    return 0;

   421

}

   422

   423

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

   424

   425

/**

   426

   Searches the string list for an index and allocates a new string.

   427

   \return 0 in case of success, else < 0

   428

   \todo documentation

   429

*/

   430

   431

int ec_slave_locate_string(ec_slave_t *slave, /**< EtherCAT slave */

   432

                           unsigned int index, /**< string index */

   433

                           char **ptr /**< Address of the string pointer */

   434

                           )

   435

{

   436

    ec_sii_string_t *string;

   437

    char *err_string;

   438

   439

    // Erst alten Speicher freigeben

   440

    if (*ptr) {

   441

        kfree(*ptr);

   442

        *ptr = NULL;

   443

    }

   444

   445

    // Index 0 bedeutet "nicht belegt"

   446

    if (!index) return 0;

   447

   448

    // EEPROM-String mit Index finden und kopieren

   449

    list_for_each_entry(string, &slave->sii_strings, list) {

   450

        if (--index) continue;

   451

   452

        if (!(*ptr = (char *) kmalloc(string->size + 1, GFP_ATOMIC))) {

   453

            EC_ERR("Unable to allocate string memory.\n");

   454

            return -1;

   455

        }

   456

        memcpy(*ptr, string->data, string->size + 1);

   457

        return 0;

   458

    }

   459

   460

    EC_WARN("String %i not found in slave %i.\n", index, slave->ring_position);

   461

   462

    err_string = "(string not found)";

   463

   464

    if (!(*ptr = (char *) kmalloc(strlen(err_string) + 1, GFP_ATOMIC))) {

   465

        EC_WARN("Unable to allocate string memory.\n");

   466

        return -1;

   467

    }

   468

   469

    memcpy(*ptr, err_string, strlen(err_string) + 1);

   470

    return 0;

   471

}

   472

   473

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

   474

   475

/**

   476

   Prepares an FMMU configuration.

   477

   Configuration data for the FMMU is saved in the slave structure and is

   478

   written to the slave in ecrt_master_activate().

   479

   The FMMU configuration is done in a way, that the complete data range

   480

   of the corresponding sync manager is covered. Seperate FMMUs are configured

   481

   for each domain.

   482

   If the FMMU configuration is already prepared, the function returns with

   483

   success.

   484

   \return 0 in case of success, else < 0

   485

*/

   486