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

#include <sys/mman.h>

    37

    38

#include "master.h"

    39

#include "domain.h"

    40

#include "slave_config.h"

    41

#include "master/ioctl.h"

    42

    43

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

    44

    45

int ecrt_master_reserve(ec_master_t *master)

    46

{

    47

    if (ioctl(master->fd, EC_IOCTL_REQUEST, NULL) == -1) {

    48

        fprintf(stderr, "Failed to reserve master: %s\n",

    49

                strerror(errno));

    50

        return -1;

    51

    }

    52

    return 0;

    53

}

    54

    55

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

    56

    57

void ec_master_clear_config(ec_master_t *master)

    58

{

    59

    ec_domain_t *d, *next_d;

    60

    ec_slave_config_t *c, *next_c;

    61

    62

    d = master->first_domain;

    63

    while (d) {

    64

        next_d = d->next;

    65

        ec_domain_clear(d);

    66

        d = next_d;

    67

    }

    68

    master->first_domain = NULL;

    69

    70

    c = master->first_config;

    71

    while (c) {

    72

        next_c = c->next;

    73

        ec_slave_config_clear(c);

    74

        c = next_c;

    75

    }

    76

    master->first_config = NULL;

    77

}

    78

    79

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

    80

    81

void ec_master_clear(ec_master_t *master)

    82

{

    83

    if (master->process_data)  {

    84

        munmap(master->process_data, master->process_data_size);

    85

    }

    86

    87

    ec_master_clear_config(master);

    88

    89

    if (master->fd != -1) {

    90

        close(master->fd);

    91

    }

    92

}

    93

    94

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

    95

    96

void ec_master_add_domain(ec_master_t *master, ec_domain_t *domain)

    97

{

    98

    if (master->first_domain) {

    99

        ec_domain_t *d = master->first_domain;

   100

        while (d->next) {

   101

            d = d->next;

   102

        }

   103

        d->next = domain;

   104

    } else {

   105

        master->first_domain = domain;

   106

    }

   107

}

   108

   109

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

   110

   111

ec_domain_t *ecrt_master_create_domain(ec_master_t *master)

   112

{

   113

    ec_domain_t *domain;

   114

    int index;

   115

   116

    domain = malloc(sizeof(ec_domain_t));

   117

    if (!domain) {

   118

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

   119

        return 0;

   120

    }

   121

   122

    index = ioctl(master->fd, EC_IOCTL_CREATE_DOMAIN, NULL);

   123

    if (index == -1) {

   124

        fprintf(stderr, "Failed to create domain: %s\n", strerror(errno));

   125

        free(domain);

   126

        return 0;

   127

    }

   128

   129

    domain->next = NULL;

   130

    domain->index = (unsigned int) index;

   131

    domain->master = master;

   132

    domain->process_data = NULL;

   133

   134

    ec_master_add_domain(master, domain);

   135

   136

    return domain;

   137

}

   138

   139

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

   140

   141

void ec_master_add_slave_config(ec_master_t *master, ec_slave_config_t *sc)

   142

{

   143

    if (master->first_config) {

   144

        ec_slave_config_t *c = master->first_config;

   145

        while (c->next) {

   146

            c = c->next;

   147

        }

   148

        c->next = sc;

   149

    } else {

   150

        master->first_config = sc;

   151

    }

   152

}

   153

   154

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

   155

   156

ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,

   157

        uint16_t alias, uint16_t position, uint32_t vendor_id,

   158

        uint32_t product_code)

   159

{

   160

    ec_ioctl_config_t data;

   161

    ec_slave_config_t *sc;

   162

    int index;

   163

   164

    sc = malloc(sizeof(ec_slave_config_t));

   165

    if (!sc) {

   166

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

   167

        return 0;

   168

    }

   169

   170

    data.alias = alias;

   171

    data.position = position;

   172

    data.vendor_id = vendor_id;

   173

    data.product_code = product_code;

   174

   175

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

   176

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

   177

                strerror(errno));

   178

        free(sc);

   179

        return 0;

   180

    }

   181

   182

    sc->next = NULL;

   183

    sc->master = master;

   184

    sc->index = data.config_index;

   185

    sc->alias = alias;

   186

    sc->position = position;

   187

    sc->first_sdo_request = NULL;

   188

    sc->first_voe_handler = NULL;

   189

   190

    ec_master_add_slave_config(master, sc);

   191

   192

    return sc;

   193

}

   194

   195

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

   196

   197

int ecrt_master(ec_master_t* master, ec_master_info_t *master_info)

   198

{

   199

    ec_ioctl_master_t data;

   200

   201

    if (ioctl(master->fd, EC_IOCTL_MASTER, &data) < 0) {

   202

        fprintf(stderr, "Failed to get master info: %s\n", strerror(errno));

   203

        return -1;

   204

    }

   205

   206

    master_info->slave_count = data.slave_count;

   207

    master_info->link_up = data.devices[0].link_state;

   208

    master_info->scan_busy = data.scan_busy;

   209

    master_info->app_time = data.app_time;

   210

    return 0;

   211

}

   212

   213

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

   214

   215

int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,

   216

        ec_slave_info_t *slave_info)

   217

{

   218

    ec_ioctl_slave_t data;

   219

    int index, i;

   220

   221

    data.position = slave_position;

   222

   223

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

   224

        fprintf(stderr, "Failed to get slave info: %s\n", strerror(errno));

   225

        return -1;

   226

    }

   227

   228

    slave_info->position = data.position;

   229

    slave_info->vendor_id = data.vendor_id;

   230

    slave_info->product_code = data.product_code;

   231

    slave_info->revision_number = data.revision_number;

   232

    slave_info->serial_number = data.serial_number;

   233

    slave_info->alias = data.alias;

   234

    slave_info->current_on_ebus = data.current_on_ebus;

   235

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

   236

    	slave_info->ports[i].desc = data.ports[i].desc;

   237

    	slave_info->ports[i].link.link_up = data.ports[i].link.link_up;

   238

    	slave_info->ports[i].link.loop_closed = data.ports[i].link.loop_closed;

   239

    	slave_info->ports[i].link.signal_detected = data.ports[i].link.signal_detected;

   240

    	slave_info->ports[i].receive_time = data.ports[i].receive_time;

   241

    	slave_info->ports[i].next_slave = data.ports[i].next_slave;

   242

    	slave_info->ports[i].delay_to_next_dc = data.ports[i].delay_to_next_dc;

   243

    }

   244

    slave_info->al_state = data.al_state;

   245

    slave_info->error_flag = data.error_flag;

   246

    slave_info->sync_count = data.sync_count;

   247

    slave_info->sdo_count = data.sdo_count;

   248

    strncpy(slave_info->name, data.name, EC_MAX_STRING_LENGTH);

   249

    return 0;

   250

}

   251

   252

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

   253

   254

int ecrt_master_get_sync_manager(ec_master_t *master, uint16_t slave_position,

   255

        uint8_t sync_index, ec_sync_info_t *sync)

   256

{

   257

    ec_ioctl_slave_sync_t data;

   258

   259

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   260

        return -ENOENT;

   261

   262

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

   263

    data.slave_position = slave_position;

   264

    data.sync_index = sync_index;

   265

   266

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

   267

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

   268

                strerror(errno));

   269

        return -1; // FIXME

   270

    }

   271

   272

    sync->index = sync_index;

   273

    sync->dir = EC_READ_BIT(&data.control_register, 2) ?

   274

        EC_DIR_OUTPUT : EC_DIR_INPUT;

   275

    sync->n_pdos = data.pdo_count;

   276

    sync->pdos = NULL;

   277

    sync->watchdog_mode = EC_READ_BIT(&data.control_register, 6) ?

   278

        EC_WD_ENABLE : EC_WD_DISABLE;

   279

   280

    return 0;

   281

}

   282

   283

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

   284

   285

int ecrt_master_get_pdo(ec_master_t *master, uint16_t slave_position,

   286

        uint8_t sync_index, uint16_t pos, ec_pdo_info_t *pdo)

   287

{

   288

    ec_ioctl_slave_sync_pdo_t data;

   289

   290

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   291

        return -ENOENT;

   292

   293

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

   294

    data.slave_position = slave_position;

   295

    data.sync_index = sync_index;

   296

    data.pdo_pos = pos;

   297

   298

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

   299

        fprintf(stderr, "Failed to get pdo information: %s\n",

   300

                strerror(errno));

   301

        return -1; // FIXME

   302

    }

   303

   304

    pdo->index = data.index;

   305

    pdo->n_entries = data.entry_count;

   306

    pdo->entries = NULL;

   307

   308

    return 0;

   309

}

   310

   311

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

   312

   313

int ecrt_master_get_pdo_entry(ec_master_t *master, uint16_t slave_position,

   314

        uint8_t sync_index, uint16_t pdo_pos, uint16_t entry_pos,

   315

        ec_pdo_entry_info_t *entry)

   316

{

   317

    ec_ioctl_slave_sync_pdo_entry_t data;

   318

   319

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   320

        return -ENOENT;

   321

   322

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

   323

    data.slave_position = slave_position;

   324

    data.sync_index = sync_index;

   325

    data.pdo_pos = pdo_pos;

   326

    data.entry_pos = entry_pos;

   327

   328

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

   329

        fprintf(stderr, "Failed to get pdo entry information: %s\n",

   330

                strerror(errno));

   331

        return -1; // FIXME

   332

    }

   333

   334

    entry->index = data.index;

   335

    entry->subindex = data.subindex;

   336

    entry->bit_length = data.bit_length;

   337

   338

    return 0;

   339

}

   340

   341

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

   342

   343

int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position,

   344

        uint16_t index, uint8_t subindex, uint8_t *data,

   345

        size_t data_size, uint32_t *abort_code)

   346

{

   347

    ec_ioctl_slave_sdo_download_t download;

   348

   349

    download.slave_position = slave_position;

   350

    download.sdo_index = index;

   351

    download.sdo_entry_subindex = subindex;

   352

    download.complete_access = 0;

   353

    download.data_size = data_size;

   354

    download.data = data;

   355

   356

    if (ioctl(master->fd, EC_IOCTL_SLAVE_SDO_DOWNLOAD, &download) == -1) {

   357

        if (errno == EIO && abort_code) {

   358

            *abort_code = download.abort_code;

   359

        }

   360

        fprintf(stderr, "Failed to execute SDO download: %s\n",

   361

            strerror(errno));

   362

        return -1;

   363

    }

   364

   365

    return 0;

   366

}

   367

   368

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

   369

   370

int ecrt_master_sdo_download_complete(ec_master_t *master,

   371

        uint16_t slave_position, uint16_t index, uint8_t *data,

   372

        size_t data_size, uint32_t *abort_code)

   373

{

   374

    ec_ioctl_slave_sdo_download_t download;

   375

   376

    download.slave_position = slave_position;

   377

    download.sdo_index = index;

   378

    download.sdo_entry_subindex = 0;

   379

    download.complete_access = 1;

   380

    download.data_size = data_size;

   381

    download.data = data;

   382

   383

    if (ioctl(master->fd, EC_IOCTL_SLAVE_SDO_DOWNLOAD, &download) == -1) {

   384

        if (errno == EIO && abort_code) {

   385

            *abort_code = download.abort_code;

   386

        }

   387

        fprintf(stderr, "Failed to execute SDO download: %s\n",

   388

            strerror(errno));

   389

        return -1;

   390

    }

   391

   392

    return 0;

   393

}

   394

   395

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

   396

   397

int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,

   398

        uint16_t index, uint8_t subindex, uint8_t *target,

   399

        size_t target_size, size_t *result_size, uint32_t *abort_code)

   400

{

   401

    ec_ioctl_slave_sdo_upload_t upload;

   402

   403

    upload.slave_position = slave_position;

   404

    upload.sdo_index = index;

   405

    upload.sdo_entry_subindex = subindex;

   406

    upload.target_size = target_size;

   407

    upload.target = target;

   408

   409

    if (ioctl(master->fd, EC_IOCTL_SLAVE_SDO_UPLOAD, &upload) == -1) {

   410

        if (errno == EIO && abort_code) {

   411

            *abort_code = upload.abort_code;

   412

        }

   413

        fprintf(stderr, "Failed to execute SDO upload: %s\n",

   414

                strerror(errno));

   415

        return -1;

   416

    }

   417

   418

    *result_size = upload.data_size;

   419

    return 0;

   420

}

   421

   422

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

   423

   424

int ecrt_master_write_idn(ec_master_t *master, uint16_t slave_position,

   425

        uint8_t drive_no, uint16_t idn, uint8_t *data, size_t data_size,

   426

        uint16_t *error_code)

   427

{

   428

    ec_ioctl_slave_soe_write_t io;

   429

   430

    io.slave_position = slave_position;

   431

    io.drive_no = drive_no;

   432

    io.idn = idn;

   433

    io.data_size = data_size;

   434

    io.data = data;

   435

   436

    if (ioctl(master->fd, EC_IOCTL_SLAVE_SOE_WRITE, &io) == -1) {

   437

        if (errno == EIO && error_code) {

   438

            *error_code = io.error_code;

   439

        }

   440

        fprintf(stderr, "Failed to write IDN: %s\n", strerror(errno));

   441

        return -1;

   442

    }

   443

   444

    return 0;

   445

}

   446

   447

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

   448

   449

int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position,

   450

        uint8_t drive_no, uint16_t idn, uint8_t *target, size_t target_size,

   451

        size_t *result_size, uint16_t *error_code)

   452

{

   453

    ec_ioctl_slave_soe_read_t io;

   454

   455

    io.slave_position = slave_position;

   456

    io.drive_no = drive_no;

   457

    io.idn = idn;

   458

    io.mem_size = target_size;

   459

    io.data = target;

   460

   461

    if (ioctl(master->fd, EC_IOCTL_SLAVE_SOE_READ, &io) == -1) {

   462

        if (errno == EIO && error_code) {

   463

            *error_code = io.error_code;

   464

        }

   465

        fprintf(stderr, "Failed to read IDN: %s\n", strerror(errno));

   466

        return -1;

   467

    }

   468

   469

    *result_size = io.data_size;

   470

    return 0;

   471

}

   472

   473

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

   474

   475

int ecrt_master_activate(ec_master_t *master)

   476

{

   477

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   478

                &master->process_data_size) == -1) {

   479

        fprintf(stderr, "Failed to activate master: %s\n",

   480

                strerror(errno));

   481

        return -1; // FIXME

   482

    }

   483

   484

    if (master->process_data_size) {

   485

        master->process_data = mmap(0, master->process_data_size,

   486

                PROT_READ | PROT_WRITE, MAP_SHARED, master->fd, 0);

   487

        if (master->process_data == MAP_FAILED) {

   488

            fprintf(stderr, "Failed to map process data: %s", strerror(errno));

   489

            master->process_data = NULL;

   490

            master->process_data_size = 0;

   491

            return -1; // FIXME

   492

        }