1

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

     2

 *  

     3

 *  $Id$

     4

 *  

     5

 *  Copyright (C) 2006-2009  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *  

     7

 *  This file is part of the IgH EtherCAT master userspace library.

     8

 *  

     9

 *  The IgH EtherCAT master userspace library is free software; you can

    10

 *  redistribute it and/or modify it under the terms of the GNU Lesser General

    11

 *  Public License as published by the Free Software Foundation; version 2.1

    12

 *  of the License.

    13

 *

    14

 *  The IgH EtherCAT master userspace library is distributed in the hope that

    15

 *  it will be useful, but WITHOUT ANY WARRANTY; without even the implied

    16

 *  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU Lesser General Public License for more details.

    18

 *

    19

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

    20

 *  along with the IgH EtherCAT master userspace library. If not, see

    21

 *  <http://www.gnu.org/licenses/>.

    22

 *  

    23

 *  ---

    24

 *  

    25

 *  The license mentioned above concerns the source code only. Using the

    26

 *  EtherCAT technology and brand is only permitted in compliance with the

    27

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    28

 *

    29

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

    30

    31

#include <stdlib.h>

    32

#include <sys/ioctl.h>

    33

#include <stdio.h>

    34

#include <errno.h>

    35

#include <string.h>

    36

    37

#include "slave_config.h"

    38

#include "domain.h"

    39

#include "sdo_request.h"

    40

#include "voe_handler.h"

    41

#include "master.h"

    42

#include "master/ioctl.h"

    43

    44

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

    45

    46

void ec_slave_config_clear(ec_slave_config_t *sc)

    47

{

    48

    ec_sdo_request_t *r, *next_r;

    49

    ec_voe_handler_t *v, *next_v;

    50

    51

    r = sc->first_sdo_request;

    52

    while (r) {

    53

        next_r = r->next;

    54

        ec_sdo_request_clear(r);

    55

        r = next_r;

    56

    }

    57

    58

    59

    v = sc->first_voe_handler;

    60

    while (v) {

    61

        next_v = v->next;

    62

        ec_voe_handler_clear(v);

    63

        v = next_v;

    64

    }

    65

}

    66

    67

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

    68

    69

int ecrt_slave_config_sync_manager(ec_slave_config_t *sc, uint8_t sync_index,

    70

        ec_direction_t dir, ec_watchdog_mode_t watchdog_mode)

    71

{

    72

    ec_ioctl_config_t data;

    73

    unsigned int i;

    74

    75

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

    76

        return -ENOENT;

    77

    78

    memset(&data, 0x00, sizeof(ec_ioctl_config_t));

    79

    data.config_index = sc->index;

    80

    data.syncs[sync_index].dir = dir;

    81

    data.syncs[sync_index].watchdog_mode = watchdog_mode;

    82

    data.syncs[sync_index].config_this = 1;

    83

    84

    if (ioctl(sc->master->fd, EC_IOCTL_SC_SYNC, &data) == -1) {

    85

        fprintf(stderr, "Failed to config sync manager: %s\n",

    86

                strerror(errno));

    87

        return -1; // FIXME

    88

    }

    89

    90

    return 0;

    91

}

    92

    93

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

    94

    95

void ecrt_slave_config_watchdog(ec_slave_config_t *sc,

    96

        uint16_t divider, uint16_t intervals)

    97

{

    98

    ec_ioctl_config_t data;

    99

   100

    memset(&data, 0x00, sizeof(ec_ioctl_config_t));

   101

    data.config_index = sc->index;

   102

    data.watchdog_divider = divider;

   103

    data.watchdog_intervals = intervals;

   104

   105

    if (ioctl(sc->master->fd, EC_IOCTL_SC_WATCHDOG, &data) == -1) {

   106

        fprintf(stderr, "Failed to config watchdog: %s\n",

   107

                strerror(errno));

   108

    }

   109

}

   110

   111

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

   112

   113

void ecrt_slave_config_overlapping_pdos(ec_slave_config_t *sc,

   114

        uint8_t allow_overlapping_pdos)

   115

{

   116

    ec_ioctl_config_t data;

   117

   118

    memset(&data, 0x00, sizeof(ec_ioctl_config_t));

   119

    data.config_index = sc->index;

   120

    data.allow_overlapping_pdos = allow_overlapping_pdos;

   121

   122

    if (ioctl(sc->master->fd, EC_IOCTL_SC_OVERLAPPING_IO, &data) == -1) {

   123

        fprintf(stderr, "Failed to config overlapping PDOs: %s\n",

   124

                strerror(errno));

   125

    }

   126

}

   127

   128

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

   129

   130

int ecrt_slave_config_pdo_assign_add(ec_slave_config_t *sc,

   131

        uint8_t sync_index, uint16_t pdo_index)

   132

{

   133

    ec_ioctl_config_pdo_t data;

   134

   135

    data.config_index = sc->index;

   136

    data.sync_index = sync_index;

   137

    data.index = pdo_index;

   138

   139

    if (ioctl(sc->master->fd, EC_IOCTL_SC_ADD_PDO, &data) == -1) {

   140

        fprintf(stderr, "Failed to add PDO: %s\n",

   141

                strerror(errno));

   142

        return -1;  // FIXME

   143

    }

   144

   145

    return 0;

   146

}

   147

   148

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

   149

   150

void ecrt_slave_config_pdo_assign_clear(ec_slave_config_t *sc,

   151

        uint8_t sync_index)

   152

{

   153

    ec_ioctl_config_pdo_t data;

   154

   155

    data.config_index = sc->index;

   156

    data.sync_index = sync_index;

   157

   158

    if (ioctl(sc->master->fd, EC_IOCTL_SC_CLEAR_PDOS, &data) == -1) {

   159

        fprintf(stderr, "Failed to clear PDOs: %s\n",

   160

                strerror(errno));

   161

    }

   162

}

   163

   164

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

   165

   166

int ecrt_slave_config_pdo_mapping_add(ec_slave_config_t *sc,

   167

        uint16_t pdo_index, uint16_t entry_index, uint8_t entry_subindex,

   168

        uint8_t entry_bit_length)

   169

{

   170

    ec_ioctl_add_pdo_entry_t data;

   171

   172

    data.config_index = sc->index;

   173

    data.pdo_index = pdo_index;

   174

    data.entry_index = entry_index;

   175

    data.entry_subindex = entry_subindex;

   176

    data.entry_bit_length = entry_bit_length;

   177

   178

    if (ioctl(sc->master->fd, EC_IOCTL_SC_ADD_ENTRY, &data) == -1) {

   179

        fprintf(stderr, "Failed to add PDO entry: %s\n",

   180

                strerror(errno));

   181

        return -1;  // FIXME

   182

    }

   183

   184

    return 0;

   185

}

   186

   187

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

   188

   189

void ecrt_slave_config_pdo_mapping_clear(ec_slave_config_t *sc,

   190

        uint16_t pdo_index)

   191

{

   192

    ec_ioctl_config_pdo_t data;

   193

   194

    data.config_index = sc->index;

   195

    data.index = pdo_index;

   196

   197

    if (ioctl(sc->master->fd, EC_IOCTL_SC_CLEAR_ENTRIES, &data) == -1) {

   198

        fprintf(stderr, "Failed to clear PDO entries: %s\n",

   199

                strerror(errno));

   200

    }

   201

}

   202

   203

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

   204

   205

int ecrt_slave_config_pdos(ec_slave_config_t *sc,

   206

        unsigned int n_syncs, const ec_sync_info_t syncs[])

   207

{

   208

    int ret;

   209

    unsigned int i, j, k;

   210

    const ec_sync_info_t *sync_info;

   211

    const ec_pdo_info_t *pdo_info;

   212

    const ec_pdo_entry_info_t *entry_info;

   213

   214

    if (!syncs)

   215

        return 0;

   216

   217

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

   218

        sync_info = &syncs[i];

   219

   220

        if (sync_info->index == (uint8_t) EC_END)

   221

            break;

   222

   223

        if (sync_info->index >= EC_MAX_SYNC_MANAGERS) {

   224

            fprintf(stderr, "Invalid sync manager index %u!\n",

   225

                    sync_info->index);

   226

            return -ENOENT;

   227

        }

   228

   229

        ret = ecrt_slave_config_sync_manager(sc, sync_info->index,

   230

                sync_info->dir, sync_info->watchdog_mode);

   231

        if (ret)

   232

            return ret;

   233

   234

        if (sync_info->n_pdos && sync_info->pdos) {

   235

            ecrt_slave_config_pdo_assign_clear(sc, sync_info->index);

   236

   237

            for (j = 0; j < sync_info->n_pdos; j++) {

   238

                pdo_info = &sync_info->pdos[j];

   239

   240

                ret = ecrt_slave_config_pdo_assign_add(

   241

                        sc, sync_info->index, pdo_info->index);

   242

                if (ret)

   243

                    return ret;

   244

   245

                if (pdo_info->n_entries && pdo_info->entries) {

   246

                    ecrt_slave_config_pdo_mapping_clear(sc, pdo_info->index);

   247

   248

                    for (k = 0; k < pdo_info->n_entries; k++) {

   249

                        entry_info = &pdo_info->entries[k];

   250

   251

                        ret = ecrt_slave_config_pdo_mapping_add(sc,

   252

                                pdo_info->index, entry_info->index,

   253

                                entry_info->subindex,

   254

                                entry_info->bit_length);

   255

                        if (ret)

   256

                            return ret;

   257

                    }

   258

                }

   259

            }

   260

        }

   261

    }

   262

   263

    return 0;

   264

}

   265

   266

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

   267

   268

int ecrt_slave_config_reg_pdo_entry(

   269

        ec_slave_config_t *sc,

   270

        uint16_t index,

   271

        uint8_t subindex,

   272

        ec_domain_t *domain,

   273

        unsigned int *bit_position

   274

        )

   275

{

   276

    ec_ioctl_reg_pdo_entry_t data;

   277

    int ret;

   278

   279

    data.config_index = sc->index;

   280

    data.entry_index = index;

   281

    data.entry_subindex = subindex;

   282

    data.domain_index = domain->index;

   283

   284

    ret = ioctl(sc->master->fd, EC_IOCTL_SC_REG_PDO_ENTRY, &data);

   285

    if (ret == -1) {

   286

        fprintf(stderr, "Failed to register PDO entry: %s\n",

   287

                strerror(errno));

   288

        return -2; // FIXME

   289

    }

   290

   291

    if (bit_position) {

   292

        *bit_position = data.bit_position;

   293

    } else {

   294

        if (data.bit_position) {

   295

            fprintf(stderr, "PDO entry 0x%04X:%02X does not byte-align "

   296

                    "in config %u:%u.\n", index, subindex,

   297

                    sc->alias, sc->position);

   298

            return -3; // FIXME

   299

        }

   300

    }

   301

   302

    return ret;

   303

}

   304

   305

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

   306

   307

void ecrt_slave_config_dc(ec_slave_config_t *sc, uint16_t assign_activate,

   308

        uint32_t sync0_cycle_time, uint32_t sync0_shift_time,

   309

        uint32_t sync1_cycle_time, uint32_t sync1_shift_time)

   310

{

   311

    ec_ioctl_config_t data;

   312

   313

    data.config_index = sc->index;

   314

    data.dc_assign_activate = assign_activate;

   315

    data.dc_sync[0].cycle_time = sync0_cycle_time;

   316

    data.dc_sync[0].shift_time = sync0_shift_time;

   317

    data.dc_sync[1].cycle_time = sync1_cycle_time;

   318

    data.dc_sync[1].shift_time = sync1_shift_time;

   319

   320

    if (ioctl(sc->master->fd, EC_IOCTL_SC_DC, &data) == -1) {

   321

        fprintf(stderr, "Failed to set assign_activate word.\n");

   322

    }

   323

}

   324

   325

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

   326

   327

int ecrt_slave_config_sdo(ec_slave_config_t *sc, uint16_t index,

   328

        uint8_t subindex, const uint8_t *sdo_data, size_t size)

   329

{

   330

    ec_ioctl_sc_sdo_t data;

   331

   332

    data.config_index = sc->index;

   333

    data.index = index;

   334

    data.subindex = subindex;

   335

    data.data = sdo_data;

   336

    data.size = size;

   337

    data.complete_access = 0;

   338

   339

    if (ioctl(sc->master->fd, EC_IOCTL_SC_SDO, &data) == -1) {

   340

        fprintf(stderr, "Failed to configure SDO.\n");

   341

        return -1; // FIXME

   342

    }

   343

   344

    return 0;

   345

}

   346

   347

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

   348

   349

int ecrt_slave_config_complete_sdo(ec_slave_config_t *sc, uint16_t index,

   350

        const uint8_t *sdo_data, size_t size)

   351

{

   352

    ec_ioctl_sc_sdo_t data;

   353

   354

    data.config_index = sc->index;

   355

    data.index = index;

   356

    data.subindex = 0;

   357

    data.data = sdo_data;

   358

    data.size = size;

   359

    data.complete_access = 1;

   360

   361

    if (ioctl(sc->master->fd, EC_IOCTL_SC_SDO, &data) == -1) {

   362

        fprintf(stderr, "Failed to configure SDO.\n");

   363

        return -1; // FIXME

   364

    }

   365

   366

    return 0;

   367

}

   368

   369

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

   370

   371

int ecrt_slave_config_sdo8(ec_slave_config_t *sc, uint16_t index,

   372

        uint8_t subindex, uint8_t value)

   373

{

   374

    uint8_t data[1];

   375

   376

    EC_WRITE_U8(data, value);

   377

    return ecrt_slave_config_sdo(sc, index, subindex, data, 1);

   378

}

   379

   380

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

   381

   382

int ecrt_slave_config_sdo16(ec_slave_config_t *sc, uint16_t index,

   383

        uint8_t subindex, uint16_t value)

   384

{

   385

    uint8_t data[2];

   386

   387

    EC_WRITE_U16(data, value);

   388

    return ecrt_slave_config_sdo(sc, index, subindex, data, 2);

   389

}

   390

   391

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

   392

   393

int ecrt_slave_config_sdo32(ec_slave_config_t *sc, uint16_t index,

   394

        uint8_t subindex, uint32_t value)

   395

{

   396

    uint8_t data[4];

   397

   398

    EC_WRITE_U32(data, value);

   399

    return ecrt_slave_config_sdo(sc, index, subindex, data, 4);

   400

}

   401

   402

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

   403

   404

void ec_slave_config_add_sdo_request(ec_slave_config_t *sc,

   405

        ec_sdo_request_t *req)

   406

{

   407

    if (sc->first_sdo_request) {

   408

        ec_sdo_request_t *r = sc->first_sdo_request;

   409

        while (r->next) {

   410

            r = r->next;

   411

        }

   412

        r->next = req;

   413

    } else {

   414

        sc->first_sdo_request = req;

   415

    }

   416

}

   417

   418

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

   419

   420

ec_sdo_request_t *ecrt_slave_config_create_sdo_request(ec_slave_config_t *sc,

   421

        uint16_t index, uint8_t subindex, size_t size)

   422

{

   423

    ec_ioctl_sdo_request_t data;

   424

    ec_sdo_request_t *req;

   425

   426

    req = malloc(sizeof(ec_sdo_request_t));

   427

    if (!req) {

   428

        fprintf(stderr, "Failed to allocate memory.\n");

   429

        return 0;

   430

    }

   431

   432

    if (size) {

   433

        req->data = malloc(size);

   434

        if (!req->data) {

   435

            fprintf(stderr, "Failed to allocate %u bytes of SDO data"

   436

                    " memory.\n", size);

   437

            free(req);

   438

            return 0;

   439

        }

   440

    } else {

   441

        req->data = NULL;

   442

    }

   443

   444

    data.config_index = sc->index;

   445

    data.sdo_index = index;

   446

    data.sdo_subindex = subindex;

   447

    data.size = size;

   448

   449

    if (ioctl(sc->master->fd, EC_IOCTL_SC_SDO_REQUEST, &data) == -1) {

   450

        fprintf(stderr, "Failed to create SDO request: %s\n",

   451

                strerror(errno));

   452

        ec_sdo_request_clear(req);

   453

        free(req);

   454

        return NULL; 

   455

    }

   456

   457

    req->next = NULL;

   458

    req->config = sc;

   459

    req->index = data.request_index;

   460

    req->sdo_index = data.sdo_index;

   461

    req->sdo_subindex = data.sdo_subindex;

   462

    req->data_size = size;

   463

    req->mem_size = size;

   464

   465

    ec_slave_config_add_sdo_request(sc, req);

   466

   467

    return req;

   468

}

   469

   470

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

   471

   472

void ec_slave_config_add_voe_handler(ec_slave_config_t *sc,

   473

        ec_voe_handler_t *voe)

   474

{

   475

    if (sc->first_voe_handler) {

   476

        ec_voe_handler_t *v = sc->first_voe_handler;

   477

        while (v->next) {

   478

            v = v->next;

   479

        }

   480

        v->next = voe;

   481

    } else {

   482

        sc->first_voe_handler = voe;

   483

    }

   484

}

   485

   486

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

   487

   488

ec_voe_handler_t *ecrt_slave_config_create_voe_handler(ec_slave_config_t *sc,

   489

        size_t size)

   490

{

   491

    ec_ioctl_voe_t data;

   492

    ec_voe_handler_t *voe;

   493

    unsigned int index;

   494

   495

    voe = malloc(sizeof(ec_voe_handler_t));

   496

    if (!voe) {

   497

        fprintf(stderr, "Failed to allocate memory.\n");

   498

        return 0;

   499

    }

   500

   501

    if (size) {

   502

        voe->data = malloc(size);

   503

        if (!voe->data) {

   504

            fprintf(stderr, "Failed to allocate %u bytes of VoE data"

   505

                    " memory.\n", size);

   506

            free(voe);

   507

            return 0;