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

#define PFX "ec_mini: "

    43

    44

#define FREQUENCY 100

    45

    46

//#define KBUS

    47

#define PDOS

    48

#define MAPPING

    49

#define EXTERNAL_MEMORY

    50

    51

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

    52

    53

static struct timer_list timer;

    54

    55

// EtherCAT

    56

static ec_master_t *master = NULL;

    57

static ec_domain_t *domain1 = NULL;

    58

spinlock_t master_lock = SPIN_LOCK_UNLOCKED;

    59

static ec_master_state_t master_state, old_state = {};

    60

    61

// data fields

    62

#ifdef KBUS

    63

static void *r_inputs;

    64

static void *r_outputs;

    65

#endif

    66

    67

#ifdef MAPPING

    68

const ec_pdo_entry_info_t el3162_channel1[] = {

    69

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

    70

    {0x3101, 2, 16}  // value

    71

};

    72

    73

const ec_pdo_entry_info_t el3162_channel2[] = {

    74

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

    75

    {0x3102, 2, 16}  // value

    76

};

    77

    78

const ec_pdo_info_t el3162_mapping[] = {

    79

    {EC_DIR_INPUT, 0x1A00, 2, el3162_channel1},

    80

    {EC_DIR_INPUT, 0x1A01, 2, el3162_channel2},

    81

};

    82

    83

const ec_pdo_entry_info_t el2004_channels[] = {

    84

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

    85

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

    86

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

    87

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

    88

};

    89

    90

const ec_pdo_info_t el2004_mapping[] = {

    91

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

    92

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

    93

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

    94

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

    95

};

    96

#endif

    97

    98

#ifdef PDOS

    99

static uint8_t *pd; /**< Process data. */

   100

static unsigned int off_ana_in;

   101

static unsigned int off_dig_out;

   102

   103

const static ec_pdo_entry_reg_t domain1_regs[] = {

   104

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

   105

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

   106

    {}

   107

};

   108

#endif

   109

   110

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

   111

   112

void run(unsigned long data)

   113

{

   114

    static unsigned int counter = 0;

   115

    static unsigned int blink = 0;

   116

   117

    // receive

   118

    spin_lock(&master_lock);

   119

    ecrt_master_receive(master);

   120

    ecrt_domain_process(domain1);

   121

    spin_unlock(&master_lock);

   122

   123

    // process data

   124

    EC_WRITE_U8(pd + off_dig_out, blink ? 0x0F : 0x00);

   125

   126

    if (counter) {

   127

        counter--;

   128

    }

   129

    else {

   130

        counter = FREQUENCY;

   131

        blink = !blink;

   132

   133

        spin_lock(&master_lock);

   134

        ecrt_master_state(master, &master_state);

   135

        spin_unlock(&master_lock);

   136

   137

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

   138

            printk(KERN_INFO PFX "bus state changed to %i.\n",

   139

                    master_state.bus_state);

   140

        }

   141

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

   142

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

   143

                    master_state.bus_tainted);

   144

        }

   145

        if (master_state.slaves_responding !=

   146

                old_state.slaves_responding) {

   147

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

   148

                    master_state.slaves_responding);

   149

        }

   150

   151

        old_state = master_state;

   152

    }

   153

   154

#ifdef KBUS

   155

    EC_WRITE_U8(r_outputs + 2, blink ? 0xFF : 0x00);

   156

#endif

   157

   158

    // send

   159

    spin_lock(&master_lock);

   160

    ecrt_domain_queue(domain1);

   161

    spin_unlock(&master_lock);

   162

   163

    spin_lock(&master_lock);

   164

    ecrt_master_send(master);

   165

    spin_unlock(&master_lock);

   166

   167

    // restart timer

   168

    timer.expires += HZ / FREQUENCY;

   169

    add_timer(&timer);

   170

}

   171

   172

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

   173

   174

int request_lock(void *data)

   175

{

   176

    spin_lock(&master_lock);

   177

    return 0; // access allowed

   178

}

   179

   180

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

   181

   182

void release_lock(void *data)

   183

{

   184

    spin_unlock(&master_lock);

   185

}

   186

   187

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

   188

   189

int __init init_mini_module(void)

   190

{

   191

#ifdef MAPPING

   192

    ec_slave_config_t *sc;

   193

#endif

   194

#ifdef EXTERNAL_MEMORY

   195

    unsigned int size;

   196

#endif

   197

   198

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

   199

   200

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

   201

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

   202

        goto out_return;

   203

    }

   204

   205

    ecrt_master_callbacks(master, request_lock, release_lock, NULL);

   206

   207

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

   208

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

   209

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

   210

        goto out_release_master;

   211

    }

   212

   213

#ifdef MAPPING

   214

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

   215

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

   216

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

   217

        goto out_release_master;

   218

    }

   219

   220

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

   221

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

   222

        goto out_release_master;

   223

    }

   224

   225

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

   226

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

   227

        goto out_release_master;

   228

    }

   229

   230

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

   231

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

   232

        goto out_release_master;

   233

    }

   234

#endif

   235

   236

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

   237

#ifdef PDOS

   238

    if (ecrt_domain_reg_pdo_entry_list(domain1, domain1_regs)) {

   239

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

   240

        goto out_release_master;

   241

    }

   242

#endif

   243

   244

#ifdef EXTERNAL_MEMORY

   245

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

   246

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

   247

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

   248

                    " memory!\n", size);

   249

            goto out_release_master;

   250

        }

   251

        ecrt_domain_external_memory(domain1, pd);

   252

    }

   253

#endif

   254

   255

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

   256

    if (ecrt_master_activate(master)) {

   257

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

   258

#ifdef EXTERNAL_MEMORY

   259

        goto out_free_process_data;

   260

#else

   261

        goto out_release_master;

   262

#endif

   263

    }

   264

   265

#ifndef EXTERNAL_MEMORY

   266

    // Get internal process data for domain

   267

    pd = ecrt_domain_data(domain1);

   268

#endif

   269

   270

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

   271

    init_timer(&timer);

   272

    timer.function = run;

   273

    timer.expires = jiffies + 10;

   274

    add_timer(&timer);

   275

   276

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

   277

    return 0;

   278

   279

#ifdef EXTERNAL_MEMORY

   280

out_free_process_data:

   281

    kfree(pd);

   282

#endif

   283

out_release_master:

   284

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

   285

    ecrt_release_master(master);

   286

out_return:

   287

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

   288

    return -1;

   289

}

   290

   291

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

   292

   293

void __exit cleanup_mini_module(void)

   294

{

   295

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

   296

   297

    del_timer_sync(&timer);

   298

   299

#ifdef EXTERNAL_MEMORY

   300

    kfree(pd);

   301

#endif

   302

   303

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

   304

    ecrt_release_master(master);

   305

   306

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

   307

}

   308

   309

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

   310

   311

MODULE_LICENSE("GPL");

   312

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

   313

MODULE_DESCRIPTION("EtherCAT minimal test environment");

   314

   315

module_init(init_mini_module);

   316

module_exit(cleanup_mini_module);

   317

   318

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