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

}

    53

    54

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

    55

   101

ec_domain_t *ecrt_master_create_domain(ec_master_t *master)

   102

{

   103

    ec_domain_t *domain;

   104

    int index;

   105

   106

    domain = malloc(sizeof(ec_domain_t));

   107

    if (!domain) {

   108

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

   109

        return 0;

   110

    }

   111

   112

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

   113

    if (index == -1) {

   114

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

   115

        free(domain);

   116

        return 0; 

   117

    }

   118

   120

    domain->index = (unsigned int) index;

   121

    domain->master = master;

   122

    domain->process_data = NULL;

   126

    return domain;

   127

}

   128

   129

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

   130

   146

ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,

   147

        uint16_t alias, uint16_t position, uint32_t vendor_id,

   148

        uint32_t product_code)

   149

{

   150

    ec_ioctl_config_t data;

   151

    ec_slave_config_t *sc;

   152

    int index;

   153

   154

    sc = malloc(sizeof(ec_slave_config_t));

   155

    if (!sc) {

   156

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

   157

        return 0;

   158

    }

   159

   160

    data.alias = alias;

   161

    data.position = position;

   162

    data.vendor_id = vendor_id;

   163

    data.product_code = product_code;

   164

   165

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

   166

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

   167

                strerror(errno));

   168

        free(sc);

   169

        return 0; 

   170

    }

   171

   173

    sc->master = master;

   174

    sc->index = data.config_index;

   175

    sc->alias = alias;

   176

    sc->position = position;

   182

    return sc;

   183

}

   184

   185

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

   186

   187

int ecrt_master(ec_master_t* master, ec_master_info_t *master_info)

   188

{

   189

    ec_ioctl_master_t data;

   190

   191

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

   192

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

   193

        return -1;

   194

    }

   195

   196

    master_info->slave_count = data.slave_count;

   197

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

   198

    master_info->scan_busy = data.scan_busy;

   199

    master_info->app_time = data.app_time;

   200

    return 0;

   201

}

   202

   203

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

   204

   205

int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,

   206

        ec_slave_info_t *slave_info)

   207

{

   208

    ec_ioctl_slave_t data;

   209

    int index;

   210

   211

    data.position = slave_position;

   212

   213

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

   214

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

   215

        return -1;

   216

    }

   217

   218

    slave_info->position = data.position;

   219

    slave_info->vendor_id = data.vendor_id;

   220

    slave_info->product_code = data.product_code;

   221

    slave_info->revision_number = data.revision_number;

   222

    slave_info->serial_number = data.serial_number;

   223

    slave_info->alias = data.alias;

   224

    slave_info->current_on_ebus = data.current_on_ebus;

   225

    slave_info->al_state = data.al_state;

   226

    slave_info->error_flag = data.error_flag;

   227

    slave_info->sync_count = data.sync_count;

   228

    slave_info->sdo_count = data.sdo_count;

   229

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

   230

    return 0;

   231

}

   232

   233

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

   234

   235

int ecrt_master_get_sync_manager(ec_master_t *master, uint16_t slave_position,

   236

        uint8_t sync_index, ec_sync_info_t *sync)

   237

{

   238

    ec_ioctl_slave_sync_t data;

   239

   240

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   241

        return -ENOENT;

   242

   243

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

   244

    data.slave_position = slave_position;

   245

    data.sync_index = sync_index;

   246

   247

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

   248

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

   249

                strerror(errno));

   250

        return -1; // FIXME

   251

    }

   252

   253

    sync->index = sync_index;

   254

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

   255

        EC_DIR_OUTPUT : EC_DIR_INPUT;

   256

    sync->n_pdos = data.pdo_count;

   257

    sync->pdos = NULL;

   258

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

   259

        EC_WD_ENABLE : EC_WD_DISABLE;

   260

   261

    return 0;

   262

}

   263

   264

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

   265

   266

int ecrt_master_get_pdo(ec_master_t *master, uint16_t slave_position,

   267

        uint8_t sync_index, uint16_t pos, ec_pdo_info_t *pdo)

   268

{

   269

    ec_ioctl_slave_sync_pdo_t data;

   270

   271

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   272

        return -ENOENT;

   273

   274

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

   275

    data.slave_position = slave_position;

   276

    data.sync_index = sync_index;

   277

    data.pdo_pos = pos;

   278

   279

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

   280

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

   281

                strerror(errno));

   282

        return -1; // FIXME

   283

    }

   284

   285

    pdo->index = data.index;

   286

    pdo->n_entries = data.entry_count;

   287

    pdo->entries = NULL;

   288

   289

    return 0;

   290

}

   291

   292

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

   293

   294

int ecrt_master_get_pdo_entry(ec_master_t *master, uint16_t slave_position,

   295

        uint8_t sync_index, uint16_t pdo_pos, uint16_t entry_pos,

   296

        ec_pdo_entry_info_t *entry)

   297

{

   298

    ec_ioctl_slave_sync_pdo_entry_t data;

   299

   300

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   301

        return -ENOENT;

   302

   303

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

   304

    data.slave_position = slave_position;

   305

    data.sync_index = sync_index;

   306

    data.pdo_pos = pdo_pos;

   307

    data.entry_pos = entry_pos;

   308

   309

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

   310

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

   311

                strerror(errno));

   312

        return -1; // FIXME

   313

    }

   314

   315

    entry->index = data.index;

   316

    entry->subindex = data.subindex;

   317

    entry->bit_length = data.bit_length;

   318

   319

    return 0;

   320

}

   321

   322

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

   323

   324

int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position,

   325

        uint16_t index, uint8_t subindex, uint8_t *data,

   326

        size_t data_size, uint32_t *abort_code)

   327

{

   328

    ec_ioctl_slave_sdo_download_t download;

   329

   330

    download.slave_position = slave_position;

   331

    download.sdo_index = index;

   332

    download.sdo_entry_subindex = subindex;

   333

    download.data_size = data_size;

   334

    download.data = data;

   335

   336

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

   337

        if (errno == EIO && abort_code) {

   338

            *abort_code = download.abort_code;

   339

        }

   340

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

   341

            strerror(errno));

   342

        return -1;

   343

    }

   344

   345

    return 0;

   346

}

   347

   348

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

   349

   350

int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,

   351

        uint16_t index, uint8_t subindex, uint8_t *target,

   352

        size_t target_size, size_t *result_size, uint32_t *abort_code)

   353

{

   354

    ec_ioctl_slave_sdo_upload_t upload;

   355

   356

    upload.slave_position = slave_position;

   357

    upload.sdo_index = index;

   358

    upload.sdo_entry_subindex = subindex;

   359

    upload.target_size = target_size;

   360

    upload.target = target;

   361

   362

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

   363

        if (errno == EIO && abort_code) {

   364

            *abort_code = upload.abort_code;

   365

        }

   366

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

   367

                strerror(errno));

   368

        return -1;

   369

    }

   370

   371

    *result_size = upload.data_size;

   372

    return 0;

   373

}

   374

   375

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

   376

   377

int ecrt_master_write_idn(ec_master_t *master, uint16_t slave_position,

   378

        uint16_t idn, uint8_t *data, size_t data_size, uint32_t *error_code)

   379

{

   380

    ec_ioctl_slave_soe_write_t io;

   381

   382

    io.slave_position = slave_position;

   383

    io.idn = idn;

   384

    io.data_size = data_size;

   385

    io.data = data;

   386

   387

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

   388

        if (errno == EIO && error_code) {

   389

            *error_code = io.error_code;

   390

        }

   391

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

   392

        return -1;

   393

    }

   394

   395

    return 0;

   396

}

   397

   398

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

   399

   400

int ecrt_master_read_idn(ec_master_t *master, uint16_t slave_position,

   401

        uint16_t idn, uint8_t *target, size_t target_size,

   402

        size_t *result_size, uint32_t *error_code)

   403

{

   404

    ec_ioctl_slave_soe_read_t io;

   405

   406

    io.slave_position = slave_position;

   407

    io.idn = idn;

   408

    io.mem_size = target_size;

   409

    io.data = target;

   410

   411

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

   412

        if (errno == EIO && error_code) {

   413

            *error_code = io.error_code;

   414

        }

   415

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

   416

        return -1;

   417

    }

   418

   419

    *result_size = io.data_size;

   420

    return 0;

   421

}

   422

   423

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

   424

   425

int ecrt_master_activate(ec_master_t *master)

   426

{

   427

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   428

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

   429

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

   430

                strerror(errno));

   431

        return -1; // FIXME

   432

    }

   433

   434

    if (master->process_data_size) {

   435

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

   436

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

   437

        if (master->process_data == MAP_FAILED) {

   438

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

   439

            master->process_data = NULL;

   440

            master->process_data_size = 0;

   441

            return -1; // FIXME

   442

        }

   443

   444

        // Access the mapped region to cause the initial page fault

   445

        printf("pd: %x\n", master->process_data[0]);

   446

    }

   447

   448

    return 0;

   449

}

   450

   451

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

   452

   453

void ecrt_master_deactivate(ec_master_t *master)

   454

{

   455

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

   456

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

   457

        return;

   458

    }

   459

}

   460

   461

   462

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

   463

   464

int ecrt_master_set_send_interval(ec_master_t *master,size_t send_interval_us)

   465

{

   466

    if (ioctl(master->fd, EC_IOCTL_SET_SEND_INTERVAL,

   467

                &send_interval_us) == -1) {

   468

        fprintf(stderr, "Failed to set send interval: %s\n",

   469

                strerror(errno));

   470

        return -1; // FIXME

   471

    }

   472

    return 0;

   473

}

   474

   475

   476

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

   477

   478

void ecrt_master_send(ec_master_t *master)

   479

{

   480

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

   481

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

   482

    }

   483

}

   484

   485

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

   486

   487

void ecrt_master_receive(ec_master_t *master)

   488

{

   489

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

   490

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

   491

    }

   492

}

   493

   494

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

   495

   496