1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    15

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

 *  You should have received a copy of the GNU General Public License

    20

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    21

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT master methods.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

#include <linux/kernel.h>

    43

#include <linux/string.h>

    44

#include <linux/slab.h>

    45

#include <linux/delay.h>

    46

#include <linux/device.h>

    47

#include <linux/version.h>

    48

    49

#include "../include/ecrt.h"

    50

#include "globals.h"

    51

#include "slave.h"

    52

#include "slave_config.h"

    53

#include "device.h"

    54

#include "datagram.h"

    55

#ifdef EC_EOE

    56

#include "ethernet.h"

    57

#endif

    58

#include "master.h"

    59

    60

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

    61

    62

#ifdef EC_HAVE_CYCLES

    63

    64

/** Frame timeout in cycles.

    65

 */

    66

static cycles_t timeout_cycles;

    67

    68

#else

    69

    70

/** Frame timeout in jiffies.

    71

 */

    72

static unsigned long timeout_jiffies;

    73

    74

#endif

    75

    76

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

    77

    78

void ec_master_clear_slave_configs(ec_master_t *);

    79

void ec_master_clear_domains(ec_master_t *);

    80

static int ec_master_idle_thread(void *);

    81

static int ec_master_operation_thread(void *);

    82

#ifdef EC_EOE

    83

void ec_master_eoe_run(unsigned long);

    84

#endif

    85

    86

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

    87

    88

/** Static variables initializer.

    89

*/

    90

void ec_master_init_static(void)

    91

{

    92

#ifdef EC_HAVE_CYCLES

    93

    timeout_cycles = (cycles_t) EC_IO_TIMEOUT /* us */ * (cpu_khz / 1000);

    94

#else

    95

    // one jiffy may always elapse between time measurement

    96

    timeout_jiffies = max(EC_IO_TIMEOUT * HZ / 1000000, 1);

    97

#endif

    98

}

    99

   100

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

   101

   102

/**

   103

   Master constructor.

   104

   \return 0 in case of success, else < 0

   105

*/

   106

   107

int ec_master_init(ec_master_t *master, /**< EtherCAT master */

   108

        unsigned int index, /**< master index */

   109

        const uint8_t *main_mac, /**< MAC address of main device */

   110

        const uint8_t *backup_mac, /**< MAC address of backup device */

   111

        dev_t device_number, /**< Character device number. */

   112

        struct class *class /**< Device class. */

   113

        )

   114

{

   115

    master->index = index;

   116

    master->reserved = 0;

   117

   118

    init_MUTEX(&master->master_sem);

   119

   120

    master->main_mac = main_mac;

   121

    master->backup_mac = backup_mac;

   122

    init_MUTEX(&master->device_sem);

   123

   124

    master->phase = EC_ORPHANED;

   125

    master->injection_seq_fsm = 0;

   126

    master->injection_seq_rt = 0;

   127

   128

    master->slaves = NULL;

   129

    master->slave_count = 0;

   130

   131

    INIT_LIST_HEAD(&master->configs);

   132

   133

    master->scan_busy = 0;

   134

    master->allow_scan = 1;

   135

    init_MUTEX(&master->scan_sem);

   136

    init_waitqueue_head(&master->scan_queue);

   137

   138

    master->config_busy = 0;

   139

    master->allow_config = 1;

   140

    init_MUTEX(&master->config_sem);

   141

    init_waitqueue_head(&master->config_queue);

   142

   143

    INIT_LIST_HEAD(&master->datagram_queue);

   144

    master->datagram_index = 0;

   145

   146

    INIT_LIST_HEAD(&master->domains);

   147

   148

    master->debug_level = 0;

   149

    master->stats.timeouts = 0;

   150

    master->stats.corrupted = 0;

   151

    master->stats.unmatched = 0;

   152

    master->stats.output_jiffies = 0;

   153

    master->frames_timed_out = 0;

   154

   155

    master->thread = NULL;

   156

   157

#ifdef EC_EOE

   158

    init_timer(&master->eoe_timer);

   159

    master->eoe_timer.function = ec_master_eoe_run;

   160

    master->eoe_timer.data = (unsigned long) master;

   161

    master->eoe_running = 0;

   162

    INIT_LIST_HEAD(&master->eoe_handlers);

   163

#endif

   164

   165

    master->internal_lock = SPIN_LOCK_UNLOCKED;

   166

    master->request_cb = NULL;

   167

    master->release_cb = NULL;

   168

    master->cb_data = NULL;

   169

   170

    INIT_LIST_HEAD(&master->sii_requests);

   171

    init_waitqueue_head(&master->sii_queue);

   172

   173

    INIT_LIST_HEAD(&master->slave_sdo_requests);

   174

    init_waitqueue_head(&master->sdo_queue);

   175

   176

    // init devices

   177

    if (ec_device_init(&master->main_device, master))

   178

        goto out_return;

   179

   180

    if (ec_device_init(&master->backup_device, master))

   181

        goto out_clear_main;

   182

   183

    // init state machine datagram

   184

    ec_datagram_init(&master->fsm_datagram);

   185

    snprintf(master->fsm_datagram.name, EC_DATAGRAM_NAME_SIZE, "master-fsm");

   186

    if (ec_datagram_prealloc(&master->fsm_datagram, EC_MAX_DATA_SIZE)) {

   187

        EC_ERR("Failed to allocate FSM datagram.\n");

   188

        goto out_clear_backup;

   189

    }

   190

   191

    // create state machine object

   192

    ec_fsm_master_init(&master->fsm, master, &master->fsm_datagram);

   193

   194

    // init character device

   195

    if (ec_cdev_init(&master->cdev, master, device_number))

   196

        goto out_clear_fsm;

   197

   198

#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)

   199

    master->class_device = class_device_create(class,

   200

            MKDEV(MAJOR(device_number), master->index),

   201

            NULL, "EtherCAT%u", master->index);

   202

#else

   203

    master->class_device = class_device_create(class, NULL,

   204

            MKDEV(MAJOR(device_number), master->index),

   205

            NULL, "EtherCAT%u", master->index);

   206

#endif

   207

    if (IS_ERR(master->class_device)) {

   208

        EC_ERR("Failed to create class device!\n");

   209

        goto out_clear_cdev;

   210

    }

   211

   212

    return 0;

   213

   214

out_clear_cdev:

   215

    ec_cdev_clear(&master->cdev);

   216

out_clear_fsm:

   217

    ec_fsm_master_clear(&master->fsm);

   218

    ec_datagram_clear(&master->fsm_datagram);

   219

out_clear_backup:

   220

    ec_device_clear(&master->backup_device);

   221

out_clear_main:

   222

    ec_device_clear(&master->main_device);

   223

out_return:

   224

    return -1;

   225

}

   226

   227

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

   228

   229

/** Destructor.

   230

*/

   231

void ec_master_clear(

   232

        ec_master_t *master /**< EtherCAT master */

   233

        )

   234

{

   235

    class_device_unregister(master->class_device);

   236

    ec_cdev_clear(&master->cdev);

   237

#ifdef EC_EOE

   238

    ec_master_clear_eoe_handlers(master);

   239

#endif

   240

    ec_master_clear_domains(master);

   241

    ec_master_clear_slave_configs(master);

   242

    ec_master_clear_slaves(master);

   243

    ec_fsm_master_clear(&master->fsm);

   244

    ec_datagram_clear(&master->fsm_datagram);

   245

    ec_device_clear(&master->backup_device);

   246

    ec_device_clear(&master->main_device);

   247

}

   248

   249

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

   250

   251

#ifdef EC_EOE

   252

/** Clear and free all EoE handlers.

   253

 */

   254

void ec_master_clear_eoe_handlers(

   255

        ec_master_t *master /**< EtherCAT master */

   256

        )

   257

{

   258

    ec_eoe_t *eoe, *next;

   259

   260

    list_for_each_entry_safe(eoe, next, &master->eoe_handlers, list) {

   261

        list_del(&eoe->list);

   262

        ec_eoe_clear(eoe);

   263

        kfree(eoe);

   264

    }

   265

}

   266

#endif

   267

   268

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

   269

   270

/** Clear all slave configurations.

   271

 */

   272

void ec_master_clear_slave_configs(ec_master_t *master)

   273

{

   274

    ec_slave_config_t *sc, *next;

   275

   276

    list_for_each_entry_safe(sc, next, &master->configs, list) {

   277

        list_del(&sc->list);

   278

        ec_slave_config_clear(sc);

   279

        kfree(sc);

   280

    }

   281

}

   282

   283

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

   284

   285

/** Clear all slaves.

   286

 */

   287

void ec_master_clear_slaves(ec_master_t *master)

   288

{

   289

    ec_slave_t *slave;

   290

   291

    for (slave = master->slaves;

   292

            slave < master->slaves + master->slave_count;

   293

            slave++) {

   294

        ec_slave_clear(slave);

   295

    }

   296

   297

    if (master->slaves) {

   298

        kfree(master->slaves);

   299

        master->slaves = NULL;

   300

    }

   301

   302

    master->slave_count = 0;

   303

}

   304

   305

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

   306

   307

/** Clear all domains.

   308

 */

   309

void ec_master_clear_domains(ec_master_t *master)

   310

{

   311

    ec_domain_t *domain, *next;

   312

   313

    list_for_each_entry_safe(domain, next, &master->domains, list) {

   314

        list_del(&domain->list);

   315

        ec_domain_clear(domain);

   316

        kfree(domain);

   317

    }

   318

}

   319

   320

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

   321

   322

/** Internal locking callback.

   323

 */

   324

int ec_master_request_cb(void *master /**< callback data */)

   325

{

   326

    spin_lock(&((ec_master_t *) master)->internal_lock);

   327

    return 0;

   328

}

   329

   330

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

   331

   332

/** Internal unlocking callback.

   333

 */

   334

void ec_master_release_cb(void *master /**< callback data */)

   335

{

   336

    spin_unlock(&((ec_master_t *) master)->internal_lock);

   337

}

   338

   339

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

   340

   341

/** Starts the master thread.

   342

 */

   343

int ec_master_thread_start(

   344

        ec_master_t *master, /**< EtherCAT master */

   345

        int (*thread_func)(void *), /**< thread function to start */

   346

        const char *name /**< Thread name. */

   347

        )

   348

{

   349

    EC_INFO("Starting %s thread.\n", name);

   350

    master->thread = kthread_run(thread_func, master, name);

   351

    if (IS_ERR(master->thread)) {

   352

        EC_ERR("Failed to start master thread (error %i)!\n",

   353

                (int) PTR_ERR(master->thread));

   354

        master->thread = NULL;

   355

        return -1;

   356

    }

   357

   358

    return 0;

   359

}

   360

   361

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

   362

   363

/** Stops the master thread.

   364

 */

   365

void ec_master_thread_stop(

   366

        ec_master_t *master /**< EtherCAT master */

   367

        )

   368

{

   369

    unsigned long sleep_jiffies;

   370

   371

    if (!master->thread) {

   372

        EC_WARN("ec_master_thread_stop(): Already finished!\n");

   373

        return;

   374

    }

   375

   376

    if (master->debug_level)

   377

        EC_DBG("Stopping master thread.\n");

   378

   379

    kthread_stop(master->thread);

   380

    master->thread = NULL;

   381

    EC_INFO("Master thread exited.\n");

   382

   383

    if (master->fsm_datagram.state != EC_DATAGRAM_SENT)

   384

        return;

   385

   386

    // wait for FSM datagram

   387

    sleep_jiffies = max(HZ / 100, 1); // 10 ms, at least 1 jiffy

   388

    schedule_timeout(sleep_jiffies);

   389

}

   390

   391

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

   392

   393

/** Transition function from ORPHANED to IDLE phase.

   394

 */

   395

int ec_master_enter_idle_phase(

   396

        ec_master_t *master /**< EtherCAT master */

   397

        )

   398

{

   399

    if (master->debug_level)

   400

        EC_DBG("ORPHANED -> IDLE.\n");

   401

   402

    master->request_cb = ec_master_request_cb;

   403

    master->release_cb = ec_master_release_cb;

   404

    master->cb_data = master;

   405

   406

    master->phase = EC_IDLE;

   407

    if (ec_master_thread_start(master, ec_master_idle_thread,

   408

                "EtherCAT-IDLE")) {

   409

        master->phase = EC_ORPHANED;

   410

        return -1;

   411

    }

   412

   413

    return 0;

   414

}

   415

   416

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

   417

   418

/** Transition function from IDLE to ORPHANED phase.

   419

 */

   420

void ec_master_leave_idle_phase(ec_master_t *master /**< EtherCAT master */)

   421

{

   422

    if (master->debug_level)

   423

        EC_DBG("IDLE -> ORPHANED.\n");

   424

   425

    master->phase = EC_ORPHANED;

   426

   427

#ifdef EC_EOE

   428

    ec_master_eoe_stop(master);

   429

#endif

   430

    ec_master_thread_stop(master);

   431

   432

    down(&master->master_sem);

   433

    ec_master_clear_slaves(master);

   434

    up(&master->master_sem);

   435

}

   436

   437

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

   438

   439

/** Transition function from IDLE to OPERATION phase.

   440

 */

   441

int ec_master_enter_operation_phase(ec_master_t *master /**< EtherCAT master */)

   442

{

   443

    ec_slave_t *slave;

   444

#ifdef EC_EOE

   445

    ec_eoe_t *eoe;

   446

#endif

   447

   448

    if (master->debug_level)

   449

        EC_DBG("IDLE -> OPERATION.\n");

   450

   451

    down(&master->config_sem);

   452

    master->allow_config = 0; // temporarily disable slave configuration

   453

    if (master->config_busy) {

   454

        up(&master->config_sem);

   455

   456

        // wait for slave configuration to complete

   457

        if (wait_event_interruptible(master->config_queue,

   458

                    !master->config_busy)) {

   459

            EC_INFO("Finishing slave configuration interrupted by signal.\n");

   460

            goto out_allow;

   461

        }

   462

   463

        if (master->debug_level)

   464

            EC_DBG("Waiting for pending slave configuration returned.\n");

   465

    } else {

   466

        up(&master->config_sem);

   467

    }

   468

   469

    down(&master->scan_sem);

   470

    master->allow_scan = 0; // 'lock' the slave list

   471

    if (!master->scan_busy) {

   472

        up(&master->scan_sem);

   473

    } else {

   474

        up(&master->scan_sem);

   475

   476

        // wait for slave scan to complete

   477

        if (wait_event_interruptible(master->scan_queue, !master->scan_busy)) {

   478

            EC_INFO("Waiting for slave scan interrupted by signal.\n");

   479

            goto out_allow;

   480

        }

   481

   482

        if (master->debug_level)

   483

            EC_DBG("Waiting for pending slave scan returned.\n");

   484