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_slave(ec_master_t *master, uint16_t position,

   135

        ec_slave_info_t *slave_info)

   136

{

   137

    ec_ioctl_slave_t data;

   138

    int index;

   139

   140

    data.position = 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_activate(ec_master_t *master)

   165

{

   166

    if (ioctl(master->fd, EC_IOCTL_ACTIVATE,

   167

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

   168

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

   169

                strerror(errno));

   170

        return -1; // FIXME

   171

    }

   172

   173

    if (master->process_data_size) {

   174

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

   175

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

   176

        if (master->process_data == MAP_FAILED) {

   177

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

   178

            master->process_data = NULL;

   179

            master->process_data_size = 0;

   180

            return -1; // FIXME

   181

        }

   182

   183

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

   184

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

   185

    }

   186

   187

    return 0;

   188

}

   189

   190

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

   191

   192

void ecrt_master_send(ec_master_t *master)

   193

{

   194

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

   195

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

   196

    }

   197

}

   198

   199

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

   200

   201

void ecrt_master_receive(ec_master_t *master)

   202

{

   203

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

   204

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

   205

    }

   206

}

   207

   208

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

   209

   210

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

   211

{

   212

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

   213

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

   214

    }

   215

}

   216

   217

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

   218

   219

void ecrt_master_application_time(ec_master_t *master, uint64_t app_time)

   220

{

   221

    ec_ioctl_app_time_t data;

   222

   223

    data.app_time = app_time;

   224

   225

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

   226

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

   227

                strerror(errno));

   228

    }

   229

}

   230

   231

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

   232

   233

void ecrt_master_sync_reference_clock(ec_master_t *master)

   234

{

   235

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

   236

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

   237

                strerror(errno));

   238

    }

   239

}

   240

   241

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

   242

   243

void ecrt_master_sync_slave_clocks(ec_master_t *master)

   244

{

   245

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

   246

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

   247

    }

   248

}

   249

   250

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

   251

   252

int ecrt_slave_sdo_download(ec_master_t* master, uint16_t slave_position,

   253

        uint16_t index, uint8_t subindex, uint8_t *data,

   254

        size_t data_size, uint32_t *abort_code)

   255

{

   256

    ec_ioctl_slave_sdo_download_t download;

   257

   258

    download.slave_position = slave_position;

   259

    download.sdo_index = index;

   260

    download.sdo_entry_subindex = subindex;

   261

    download.data_size = data_size;

   262

    download.data = data;

   263

   264

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

   265

        if (errno == -EIO) {

   266

            if (abort_code) {

   267

                *abort_code = download.abort_code;

   268

            }

   269

        }

   270

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

   271

            strerror(errno));

   272

        return -1;

   273

    }

   274

   275

    return 0;

   276

}

   277

   278

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

   279

   280

int ecrt_slave_sdo_upload(ec_master_t* master, uint16_t slave_position,

   281

        uint16_t index, uint8_t subindex, uint8_t *target,

   282

        size_t target_size, size_t *result_size, uint32_t *abort_code)

   283

{

   284

    ec_ioctl_slave_sdo_upload_t upload;

   285

   286

    upload.slave_position = slave_position;

   287

    upload.sdo_index = index;

   288

    upload.sdo_entry_subindex = subindex;

   289

    upload.target_size = target_size;

   290

    upload.target = target;

   291

   292

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

   293

        if (errno == -EIO) {

   294

            if (abort_code) {

   295

                *abort_code = upload.abort_code;

   296

            }

   297

        }

   298

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

   299

                strerror(errno));

   300

        return -1;

   301

    }

   302

   303

    *result_size = upload.data_size;

   304

    return 0;

   305

}

   306

   307

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