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->app_time = data.app_time;

   129

    return 0;

   130

}

   131

   132

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

   133

   134

int ecrt_master_get_slave(ec_master_t *master, uint16_t slave_position,

   135

        ec_slave_info_t *slave_info)

   136

{

   137

    ec_ioctl_slave_t data;

   138

    int index;

   139

   140

    data.position = slave_position;

   141

   142

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

   143

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

   144

        return -1;

   145

    }

   146

   147

    slave_info->position = data.position;

   148

    slave_info->vendor_id = data.vendor_id;

   149

    slave_info->product_code = data.product_code;

   150

    slave_info->revision_number = data.revision_number;

   151

    slave_info->serial_number = data.serial_number;

   152

    slave_info->alias = data.alias;

   153

    slave_info->current_on_ebus = data.current_on_ebus;

   154

    slave_info->al_state = data.al_state;

   155

    slave_info->error_flag = data.error_flag;

   156

    slave_info->sync_count = data.sync_count;

   157

    slave_info->sdo_count = data.sdo_count;

   158

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

   159

    return 0;

   160

}

   161

   162

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

   163

   164

int ecrt_master_get_sync_manager(ec_master_t *master, uint16_t slave_position,

   165

        uint8_t sync_index, ec_sync_info_t *sync)

   166

{

   167

	ec_ioctl_slave_sync_t data;

   168

   169

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   170

        return -ENOENT;

   171

   172

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

   173

    data.slave_position = slave_position;

   174

    data.sync_index = sync_index;

   175

   176

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

   177

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

   178

                strerror(errno));

   179

        return -1; // FIXME

   180

    }

   181

   182

    sync->index = sync_index;

   183

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

   184

        EC_DIR_OUTPUT : EC_DIR_INPUT;

   185

    sync->n_pdos = data.pdo_count;

   186

    sync->pdos = NULL;

   187

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

   188

        EC_WD_ENABLE : EC_WD_DISABLE;

   189

   190

    return 0;

   191

}

   192

   193

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

   194

   195

int ecrt_master_get_pdo(ec_master_t *master, uint16_t slave_position,

   196

        uint8_t sync_index, uint16_t pos, ec_pdo_info_t *pdo)

   197

{

   198

	ec_ioctl_slave_sync_pdo_t data;

   199

   200

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   201

        return -ENOENT;

   202

   203

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

   204

    data.slave_position = slave_position;

   205

    data.sync_index = sync_index;

   206

    data.pdo_pos = pos;

   207

   208

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

   209

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

   210

                strerror(errno));

   211

        return -1; // FIXME

   212

    }

   213

   214

    pdo->index = data.index;

   215

    pdo->n_entries = data.entry_count;

   216

    pdo->entries = NULL;

   217

   218

    return 0;

   219

}

   220

   221

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

   222

   223

int ecrt_master_get_pdo_entry(ec_master_t *master, uint16_t slave_position,

   224

        uint8_t sync_index, uint16_t pdo_pos, uint16_t entry_pos,

   225

        ec_pdo_entry_info_t *entry)

   226

{

   227

	ec_ioctl_slave_sync_pdo_entry_t data;

   228

   229

    if (sync_index >= EC_MAX_SYNC_MANAGERS)

   230

        return -ENOENT;

   231

   232

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

   233

    data.slave_position = slave_position;

   234

    data.sync_index = sync_index;

   235

    data.pdo_pos = pdo_pos;

   236

    data.entry_pos = entry_pos;

   237

   238

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

   239

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

   240

                strerror(errno));

   241

        return -1; // FIXME

   242

    }

   243

   244

    entry->index = data.index;

   245

    entry->subindex = data.subindex;

   246

    entry->bit_length = data.bit_length;

   247

   248

    return 0;

   249

}

   250

   251

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

   252

   253

int ecrt_master_sdo_download(ec_master_t *master, uint16_t slave_position,

   254

        uint16_t index, uint8_t subindex, uint8_t *data,

   255

        size_t data_size, uint32_t *abort_code)

   256

{

   257

    ec_ioctl_slave_sdo_download_t download;

   258

   259

    download.slave_position = slave_position;

   260

    download.sdo_index = index;

   261

    download.sdo_entry_subindex = subindex;

   262

    download.data_size = data_size;

   263

    download.data = data;

   264

   265

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

   266

        if (errno == -EIO) {

   267

            if (abort_code) {

   268

                *abort_code = download.abort_code;

   269

            }

   270

        }

   271

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

   272

            strerror(errno));

   273

        return -1;

   274

    }

   275

   276

    return 0;

   277

}

   278

   279

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

   280

   281

int ecrt_master_sdo_upload(ec_master_t *master, uint16_t slave_position,

   282

        uint16_t index, uint8_t subindex, uint8_t *target,

   283

        size_t target_size, size_t *result_size, uint32_t *abort_code)

   284

{

   285

    ec_ioctl_slave_sdo_upload_t upload;

   286

   287

    upload.slave_position = slave_position;

   288

    upload.sdo_index = index;

   289

    upload.sdo_entry_subindex = subindex;

   290

    upload.target_size = target_size;

   291

    upload.target = target;

   292

   293

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

   294

        if (errno == -EIO) {

   295

            if (abort_code) {

   296

                *abort_code = upload.abort_code;

   297

            }

   298

        }

   299

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

   300

                strerror(errno));

   301

        return -1;

   302

    }

   303

   304

    *result_size = upload.data_size;

   305

    return 0;

   306

}

   307

   308

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

   309

   310

int ecrt_master_activate(ec_master_t *master)

   311

{

   312

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   313

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

   314

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

   315

                strerror(errno));

   316

        return -1; // FIXME

   317

    }

   318

   319

    if (master->process_data_size) {

   320

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

   321

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

   322

        if (master->process_data == MAP_FAILED) {

   323

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

   324

            master->process_data = NULL;

   325

            master->process_data_size = 0;

   326

            return -1; // FIXME

   327

        }

   328

   329

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

   330

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

   331

    }

   332

   333

    return 0;

   334

}

   335

   336

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

   337

   338

void ecrt_master_deactivate(ec_master_t *master)

   339

{

   340

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

   341

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

   342

        return;

   343

    }

   344

}

   345

   346

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

   347

   348

void ecrt_master_send(ec_master_t *master)

   349

{

   350

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

   351

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

   352

    }

   353

}

   354

   355

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

   356

   357

void ecrt_master_receive(ec_master_t *master)

   358

{

   359

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

   360

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

   361

    }

   362

}

   363

   364

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

   365

   366

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

   367

{

   368

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

   369

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

   370

    }

   371

}

   372

   373

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

   374

   375

void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)

   376

{

   377

    ec_ioctl_app_time_t data;

   378

   379

    data.app_time = app_time;

   380

   381

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

   382

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

   383

                strerror(errno));

   384

    }

   385

}

   386

   387

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

   388

   389

void ecrt_master_sync_reference_clock(ec_master_t *master)

   390

{

   391

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

   392

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

   393

                strerror(errno));

   394

    }

   395

}

   396

   397

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

   398

   399

void ecrt_master_sync_slave_clocks(ec_master_t *master)

   400

{

   401

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

   402

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

   403

    }

   404

}

   405

   406

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

   407

   408

void ecrt_master_sync_monitor_queue(ec_master_t *master)

   409

{

   410

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

   411

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

   412

                strerror(errno));

   413

    }

   414

}

   415

   416

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

   417

   418

uint32_t ecrt_master_sync_monitor_process(ec_master_t *master)

   419

{

   420

    uint32_t time_diff;

   421

   422

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

   423

        time_diff = 0xffffffff;

   424

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

   425

                strerror(errno));

   426

    }

   427

   428

    return time_diff;

   429

}

   430

   431

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