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

    56

ec_domain_t *ecrt_master_create_domain(ec_master_t *master)

    57

{

    58

    ec_domain_t *domain;

    59

    int index;

    60

    61

    domain = malloc(sizeof(ec_domain_t));

    62

    if (!domain) {

    63

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

    64

        return 0;

    65

    }

    66

    67

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

    68

    if (index == -1) {

    69

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

    70

        free(domain);

    71

        return 0; 

    72

    }

    73

    74

    domain->index = (unsigned int) index;

    75

    domain->master = master;

    76

    domain->process_data = NULL;

    77

    return domain;

    78

}

    79

    80

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

    81

    82

ec_slave_config_t *ecrt_master_slave_config(ec_master_t *master,

    83

        uint16_t alias, uint16_t position, uint32_t vendor_id,

    84

        uint32_t product_code)

    85

{

    86

    ec_ioctl_config_t data;

    87

    ec_slave_config_t *sc;

    88

    int index;

    89

    90

    sc = malloc(sizeof(ec_slave_config_t));

    91

    if (!sc) {

    92

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

    93

        return 0;

    94

    }

    95

    96

    data.alias = alias;

    97

    data.position = position;

    98

    data.vendor_id = vendor_id;

    99

    data.product_code = product_code;

   100

   101

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

   102

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

   103

                strerror(errno));

   104

        free(sc);

   105

        return 0; 

   106

    }

   107

   108

    sc->master = master;

   109

    sc->index = data.config_index;

   110

    sc->alias = alias;

   111

    sc->position = position;

   112

    return sc;

   113

}

   114

   115

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

   116

   117

int ecrt_master(ec_master_t* master, ec_master_info_t *master_info)

   118

{

   119

    ec_ioctl_master_t data;

   120

   121

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

   122

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

   123

        return -1;

   124

    }

   125

   126

    master_info->slave_count = data.slave_count;

   127

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

   128

    master_info->scan_busy = data.scan_busy;

   129

    master_info->app_time = data.app_time;

   130

    return 0;

   131

}

   132

   133

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

   134

   135

int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,

   136

        ec_slave_info_t *slave_info)

   137

{

   138

    ec_ioctl_slave_t data;

   139

    int index;

   140

   141

    data.position = slave_position;

   142

   143

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

   144

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

   145

        return -1;

   146

    }

   147

   148

    slave_info->position = data.position;

   149

    slave_info->vendor_id = data.vendor_id;

   150

    slave_info->product_code = data.product_code;

   151

    slave_info->revision_number = data.revision_number;

   152

    slave_info->serial_number = data.serial_number;

   153

    slave_info->alias = data.alias;

   154

    slave_info->current_on_ebus = data.current_on_ebus;

   155

    slave_info->al_state = data.al_state;

   156

    slave_info->error_flag = data.error_flag;

   157

    slave_info->sync_count = data.sync_count;

   158

    slave_info->sdo_count = data.sdo_count;

   159

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

   160

    return 0;

   161

}

   162

   163

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

   164

   165

int ecrt_master_get_sync_manager(ec_master_t *master, uint16_t slave_position,

   166

        uint8_t sync_index, ec_sync_info_t *sync)

   167

{

   168

	ec_ioctl_slave_sync_t data;

   169

   170

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   171

        return -ENOENT;

   172

   173

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

   174

    data.slave_position = slave_position;

   175

    data.sync_index = sync_index;

   176

   177

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

   178

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

   179

                strerror(errno));

   180

        return -1; // FIXME

   181

    }

   182

   183

    sync->index = sync_index;

   184

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

   185

        EC_DIR_OUTPUT : EC_DIR_INPUT;

   186

    sync->n_pdos = data.pdo_count;

   187

    sync->pdos = NULL;

   188

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

   189

        EC_WD_ENABLE : EC_WD_DISABLE;

   190

   191

    return 0;

   192

}

   193

   194

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

   195

   196

int ecrt_master_get_pdo(ec_master_t *master, uint16_t slave_position,

   197

        uint8_t sync_index, uint16_t pos, ec_pdo_info_t *pdo)

   198

{

   199

	ec_ioctl_slave_sync_pdo_t data;

   200

   201

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   202

        return -ENOENT;

   203

   204

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

   205

    data.slave_position = slave_position;

   206

    data.sync_index = sync_index;

   207

    data.pdo_pos = pos;

   208

   209

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

   210

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

   211

                strerror(errno));

   212

        return -1; // FIXME

   213

    }

   214

   215

    pdo->index = data.index;

   216

    pdo->n_entries = data.entry_count;

   217

    pdo->entries = NULL;

   218

   219

    return 0;

   220

}

   221

   222

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

   223

   224

int ecrt_master_get_pdo_entry(ec_master_t *master, uint16_t slave_position,

   225

        uint8_t sync_index, uint16_t pdo_pos, uint16_t entry_pos,

   226

        ec_pdo_entry_info_t *entry)

   227

{

   228

	ec_ioctl_slave_sync_pdo_entry_t data;

   229

   230

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   231

        return -ENOENT;

   232

   233

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

   234

    data.slave_position = slave_position;

   235

    data.sync_index = sync_index;

   236

    data.pdo_pos = pdo_pos;

   237

    data.entry_pos = entry_pos;

   238

   239

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

   240

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

   241

                strerror(errno));

   242

        return -1; // FIXME

   243

    }

   244

   245

    entry->index = data.index;

   246

    entry->subindex = data.subindex;

   247

    entry->bit_length = data.bit_length;

   248

   249

    return 0;

   250

}

   251

   252

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

   253

   254

int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position,

   255

        uint16_t index, uint8_t subindex, uint8_t *data,

   256

        size_t data_size, uint32_t *abort_code)

   257

{

   258

    ec_ioctl_slave_sdo_download_t download;

   259

   260

    download.slave_position = slave_position;

   261

    download.sdo_index = index;

   262

    download.sdo_entry_subindex = subindex;

   263

    download.data_size = data_size;

   264

    download.data = data;

   265

   266

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

   267

        if (errno == -EIO) {

   268

            if (abort_code) {

   269

                *abort_code = download.abort_code;

   270

            }

   271

        }

   272

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

   273

            strerror(errno));

   274

        return -1;

   275

    }

   276

   277

    return 0;

   278

}

   279

   280

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

   281

   282

int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,

   283

        uint16_t index, uint8_t subindex, uint8_t *target,

   284

        size_t target_size, size_t *result_size, uint32_t *abort_code)

   285

{

   286

    ec_ioctl_slave_sdo_upload_t upload;

   287

   288

    upload.slave_position = slave_position;

   289

    upload.sdo_index = index;

   290

    upload.sdo_entry_subindex = subindex;

   291

    upload.target_size = target_size;

   292

    upload.target = target;

   293

   294

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

   295

        if (errno == -EIO) {

   296

            if (abort_code) {

   297

                *abort_code = upload.abort_code;

   298

            }

   299

        }

   300

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

   301

                strerror(errno));

   302

        return -1;

   303

    }

   304

   305

    *result_size = upload.data_size;

   306

    return 0;

   307

}

   308

   309

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

   310

   311

int ecrt_master_activate(ec_master_t *master)

   312

{

   313

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   314

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

   315

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

   316

                strerror(errno));

   317

        return -1; // FIXME

   318

    }

   319

   320

    if (master->process_data_size) {

   321

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

   322

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

   323

        if (master->process_data == MAP_FAILED) {

   324

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

   325

            master->process_data = NULL;

   326

            master->process_data_size = 0;

   327

            return -1; // FIXME

   328

        }

   329

   330

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

   331

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

   332

    }

   333

   334

    return 0;

   335

}

   336

   337

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

   338

   339

void ecrt_master_deactivate(ec_master_t *master)

   340

{

   341

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

   342

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

   343

        return;

   344

    }

   345

}

   346

   347

   348

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

   349

   350

int ecrt_master_set_max_cycle_size(ec_master_t *master,size_t max_cycle_data_size)

   351

{

   352

    if (ioctl(master->fd, EC_IOCTL_SET_MAX_CYCLE_SIZE,

   353

                &max_cycle_data_size) == -1) {

   354

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

   355

                strerror(errno));

   356

        return -1; // FIXME

   357

    }

   358

    return 0;

   359

}

   360

   361

   362

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

   363

   364

void ecrt_master_send(ec_master_t *master)

   365

{

   366

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

   367

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

   368

    }

   369

}

   370

   371

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

   372

   373

void ecrt_master_receive(ec_master_t *master)

   374

{

   375

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

   376

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

   377

    }

   378

}

   379

   380

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

   381

   382

void ecrt_master_state(const ec_master_t *master, ec_master_state_t *state)

   383

{

   384

    if (ioctl(master->fd, EC_IOCTL_MASTER_STATE, state) == -1) {

   385

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

   386

    }

   387

}

   388

   389

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

   390

   391

void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)

   392

{

   393

    ec_ioctl_app_time_t data;

   394

   395

    data.app_time = app_time;

   396

   397

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

   398

        fprintf(stderr, "Failed to set application time: %s\n",

   399

                strerror(errno));

   400

    }

   401

}

   402

   403

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

   404

   405

void ecrt_master_sync_reference_clock(ec_master_t *master)

   406

{

   407

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

   408

        fprintf(stderr, "Failed to sync reference clock: %s\n",

   409

                strerror(errno));

   410

    }

   411

}

   412

   413

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

   414

   415

void ecrt_master_sync_slave_clocks(ec_master_t *master)

   416

{

   417

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

   418

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

   419

    }

   420

}

   421

   422

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

   423

   424

void ecrt_master_sync_monitor_queue(ec_master_t *master)

   425

{

   426

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

   427

        fprintf(stderr, "Failed to queue sync monitor datagram: %s\n",

   428

                strerror(errno));

   429

    }

   430

}

   431

   432

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

   433

   434

uint32_t ecrt_master_sync_monitor_process(ec_master_t *master)

   435

{

   436

    uint32_t time_diff;

   437

   438

    if (ioctl(master->fd, EC_IOCTL_SYNC_MON_PROCESS, &time_diff) == -1) {

   439

        time_diff = 0xffffffff;

   440

        fprintf(stderr, "Failed to process sync monitor datagram: %s\n",

   441

                strerror(errno));

   442

    }

   443

   444

    return time_diff;

   445

}

   446

   447

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