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

#include <linux/module.h>

    35

#include <linux/timer.h>

    36

#include <linux/spinlock.h>

    37

#include <linux/interrupt.h>

    38

    39

#include "../../include/ecrt.h" // EtherCAT realtime interface

    40

#include "../../include/ecdb.h" // EtherCAT slave database

    41

    42

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

    43

    44

// module parameters

    45

#define FREQUENCY 100

    46

#define CONFIGURE_MAPPING

    47

#define EXTERNAL_MEMORY

    48

    49

#define PFX "ec_mini: "

    50

    51

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

    52

    53

// EtherCAT

    54

static ec_master_t *master = NULL;

    55

static ec_master_state_t master_state = {};

    56

spinlock_t master_lock = SPIN_LOCK_UNLOCKED;

    57

    58

static ec_domain_t *domain1 = NULL;

    59

static ec_domain_state_t domain1_state = {};

    60

    61

static struct timer_list timer;

    62

static unsigned int counter = 0;

    63

    64

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

    65

    66

// process data

    67

static uint8_t *domain1_pd; // process data memory

    68

    69

static unsigned int off_ana_in; // offsets for Pdo entries

    70

static unsigned int off_dig_out;

    71

    72

static unsigned int blink = 0;

    73

    74

const static ec_pdo_entry_reg_t domain1_regs[] = {

    75

    {0, 1, Beckhoff_EL3162, 0x3101, 2, &off_ana_in},

    76

    {0, 3, Beckhoff_EL2004, 0x3001, 1, &off_dig_out},

    77

    {}

    78

};

    79

    80

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

    81

    82

#ifdef CONFIGURE_MAPPING

    83

static ec_pdo_entry_info_t el3162_channel1[] = {

    84

    {0x3101, 1,  8}, // status

    85

    {0x3101, 2, 16}  // value

    86

};

    87

    88

static ec_pdo_entry_info_t el3162_channel2[] = {

    89

    {0x3102, 1,  8}, // status

    90

    {0x3102, 2, 16}  // value

    91

};

    92

    93

static ec_pdo_info_t el3162_mapping[] = {

    94

    {EC_DIR_INPUT, 0x1A00, 2, el3162_channel1},

    95

    {EC_DIR_INPUT, 0x1A01, 2, el3162_channel2},

    96

};

    97

    98

static ec_pdo_entry_info_t el2004_channels[] = {

    99

    {0x3001, 1, 1}, // Value 1

   100

    {0x3001, 2, 1}, // Value 2

   101

    {0x3001, 3, 1}, // Value 3

   102

    {0x3001, 4, 1}  // Value 4

   103

};

   104

   105

static ec_pdo_info_t el2004_mapping[] = {

   106

    {EC_DIR_OUTPUT, 0x1600, 1, &el2004_channels[0]},

   107

    {EC_DIR_OUTPUT, 0x1601, 1, &el2004_channels[1]},

   108

    {EC_DIR_OUTPUT, 0x1602, 1, &el2004_channels[2]},

   109

    {EC_DIR_OUTPUT, 0x1603, 1, &el2004_channels[3]},

   110

};

   111

#endif

   112

   113

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

   114

   115

void check_domain1_state(void)

   116

{

   117

    ec_domain_state_t ds;

   118

   119

    ecrt_domain_state(domain1, &ds);

   120

    if (ds.working_counter != domain1_state.working_counter)

   121

        printk(KERN_INFO PFX "domain1 working_counter changed to %u.\n",

   122

                ds.working_counter);

   123

   124

    if (ds.wc_state != domain1_state.wc_state)

   125

        printk(KERN_INFO PFX "domain1 wc_state changed to %u.\n",

   126

                ds.wc_state);

   127

   128

    domain1_state = ds;

   129

}

   130

   131

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

   132

   133

void check_master_state(void)

   134

{

   135

    ec_master_state_t ms;

   136

   137

    spin_lock(&master_lock);

   138

    ecrt_master_state(master, &ms);

   139

    spin_unlock(&master_lock);

   140

   141

    if (ms.bus_state != master_state.bus_state) {

   142

        printk(KERN_INFO PFX "bus state changed to %i.\n", ms.bus_state);

   143

    }

   144

    if (ms.bus_tainted != master_state.bus_tainted) {

   145

        printk(KERN_INFO PFX "tainted flag changed to %u.\n",

   146

                ms.bus_tainted);

   147

    }

   148

    if (ms.slaves_responding != master_state.slaves_responding) {

   149

        printk(KERN_INFO PFX "slaves_responding changed to %u.\n",

   150

                ms.slaves_responding);

   151

    }

   152

   153

    master_state = ms;

   154

}

   155

   156

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

   157

   158

void cyclic_task(unsigned long data)

   159

{

   160

    // receive process data

   161

    spin_lock(&master_lock);

   162

    ecrt_master_receive(master);

   163

    ecrt_domain_process(domain1);

   164

    spin_unlock(&master_lock);

   165

   166

    // check process data state (optional)

   167

    check_domain1_state();

   168

   169

    if (counter) {

   170

        counter--;

   171

    } else { // do this at FREQUENCY

   172

        counter = FREQUENCY;

   173

   174

        // calculate new process data

   175

        blink = !blink;

   176

   177

        // check for master state (optional)

   178

        check_master_state();

   179

    }

   180

   181

    // write process data

   182

    EC_WRITE_U8(domain1_pd + off_dig_out, blink ? 0x06 : 0x09);

   183

   184

    // send process data

   185

    spin_lock(&master_lock);

   186

    ecrt_domain_queue(domain1);

   187

    ecrt_master_send(master);

   188

    spin_unlock(&master_lock);

   189

   190

    // restart timer

   191

    timer.expires += HZ / FREQUENCY;

   192

    add_timer(&timer);

   193

}

   194

   195

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

   196

   197

int request_lock(void *data)

   198

{

   199

    spin_lock(&master_lock);

   200

    return 0; // access allowed

   201

}

   202

   203

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

   204

   205

void release_lock(void *data)

   206

{

   207

    spin_unlock(&master_lock);

   208

}

   209

   210

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

   211

   212

int __init init_mini_module(void)

   213

{

   214

#ifdef CONFIGURE_MAPPING

   215

    ec_slave_config_t *sc;

   216

#endif

   217

#ifdef EXTERNAL_MEMORY

   218

    unsigned int size;

   219

#endif

   220

   221

    printk(KERN_INFO PFX "Starting...\n");

   222

   223

    if (!(master = ecrt_request_master(0))) {

   224

        printk(KERN_ERR PFX "Requesting master 0 failed!\n");

   225

        goto out_return;

   226

    }

   227

   228

    ecrt_master_callbacks(master, request_lock, release_lock, NULL);

   229

   230

    printk(KERN_INFO PFX "Registering domain...\n");

   231

    if (!(domain1 = ecrt_master_create_domain(master))) {

   232

        printk(KERN_ERR PFX "Domain creation failed!\n");

   233

        goto out_release_master;

   234

    }

   235

   236

#ifdef CONFIGURE_MAPPING

   237

    printk(KERN_INFO PFX "Configuring Pdo mapping...\n");

   238

    if (!(sc = ecrt_master_slave_config(master, 0, 1, Beckhoff_EL3162))) {

   239

        printk(KERN_ERR PFX "Failed to get slave configuration.\n");

   240

        goto out_release_master;

   241

    }

   242

   243

    if (ecrt_slave_config_mapping(sc, 2, el3162_mapping)) {

   244

        printk(KERN_ERR PFX "Failed to configure Pdo mapping.\n");

   245

        goto out_release_master;

   246

    }

   247

   248

    if (!(sc = ecrt_master_slave_config(master, 0, 3, Beckhoff_EL2004))) {

   249

        printk(KERN_ERR PFX "Failed to get slave configuration.\n");

   250

        goto out_release_master;

   251

    }

   252

   253

    if (ecrt_slave_config_mapping(sc, 4, el2004_mapping)) {

   254

        printk(KERN_ERR PFX "Failed to configure Pdo mapping.\n");

   255

        goto out_release_master;

   256

    }

   257

#endif

   258

   259

    printk(KERN_INFO PFX "Registering Pdo entries...\n");

   260

    if (ecrt_domain_reg_pdo_entry_list(domain1, domain1_regs)) {

   261

        printk(KERN_ERR PFX "Pdo entry registration failed!\n");

   262

        goto out_release_master;

   263

    }

   264

   265

#ifdef EXTERNAL_MEMORY

   266

    if ((size = ecrt_domain_size(domain1))) {

   267

        if (!(domain1_pd = (uint8_t *) kmalloc(size, GFP_KERNEL))) {

   268

            printk(KERN_ERR PFX "Failed to allocate %u bytes of process data"

   269

                    " memory!\n", size);

   270

            goto out_release_master;

   271

        }

   272

        ecrt_domain_external_memory(domain1, domain1_pd);

   273

    }

   274

#endif

   275

   276

    printk(KERN_INFO PFX "Activating master...\n");

   277

    if (ecrt_master_activate(master)) {

   278

        printk(KERN_ERR PFX "Failed to activate master!\n");

   279

#ifdef EXTERNAL_MEMORY

   280

        goto out_free_process_data;

   281

#else

   282

        goto out_release_master;

   283

#endif

   284

    }

   285

   286

#ifndef EXTERNAL_MEMORY

   287

    // Get internal process data for domain

   288

    domain1_pd = ecrt_domain_data(domain1);

   289

#endif

   290

   291

    printk(KERN_INFO PFX "Starting cyclic sample thread.\n");

   292

    init_timer(&timer);

   293

    timer.function = cyclic_task;

   294

    timer.expires = jiffies + 10;

   295

    add_timer(&timer);

   296

   297

    printk(KERN_INFO PFX "Started.\n");

   298

    return 0;

   299

   300

#ifdef EXTERNAL_MEMORY

   301

out_free_process_data:

   302

    kfree(domain1_pd);

   303

#endif

   304

out_release_master:

   305

    printk(KERN_ERR PFX "Releasing master...\n");

   306

    ecrt_release_master(master);

   307

out_return:

   308

    printk(KERN_ERR PFX "Failed to load. Aborting.\n");

   309

    return -1;

   310

}

   311

   312

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

   313

   314

void __exit cleanup_mini_module(void)

   315

{

   316

    printk(KERN_INFO PFX "Stopping...\n");

   317

   318

    del_timer_sync(&timer);

   319

   320

#ifdef EXTERNAL_MEMORY

   321

    kfree(domain1_pd);

   322

#endif

   323

   324

    printk(KERN_INFO PFX "Releasing master...\n");

   325

    ecrt_release_master(master);

   326

   327

    printk(KERN_INFO PFX "Unloading.\n");

   328

}

   329

   330

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

   331

   332

MODULE_LICENSE("GPL");

   333

MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");

   334

MODULE_DESCRIPTION("EtherCAT minimal test environment");

   335

   336

module_init(init_mini_module);

   337

module_exit(cleanup_mini_module);

   338

   339

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