1

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

     2

 *

     3

 *  msr_module.c

     4

 *

     5

 *  Kernelmodul f�ür 2.6 Kernel zur Me�ßdatenerfassung, Steuerung und Regelung.

     6

 *  Zeitgeber ist der Timerinterrupt (tq)

     7

 *

     8

 *  Autor: Wilhelm Hagemeister

     9

 *

    10

 *  (C) Copyright IgH 2002

    11

 *  Ingenieurgemeinschaft IgH

    12

 *  Heinz-B�äcker Str. 34

    13

 *  D-45356 Essen

    14

 *  Tel.: +49 201/61 99 31

    15

 *  Fax.: +49 201/61 98 36

    16

 *  E-mail: hm@igh-essen.com

    17

 *

    18

 *  $Id$

    19

 *

    20

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

    21

    22

#ifndef __KERNEL__

    23

#  define __KERNEL__

    24

#endif

    25

#ifndef MODULE

    26

#  define MODULE

    27

#endif

    28

    29

#include <linux/config.h>

    30

#include <linux/module.h>

    31

    32

#include <linux/sched.h>

    33

#include <linux/kernel.h>

    34

#include <linux/vmalloc.h>

    35

#include <linux/fs.h>     /* everything... */

    36

#include <linux/proc_fs.h>

    37

#include <linux/time.h>

    38

#include <linux/timer.h>

    39

#include <linux/timex.h>  /* fuer get_cycles */

    40

#include <linux/errno.h>  /* error codes */

    41

#include <asm/msr.h> /* maschine-specific registers */

    42

#include <linux/param.h> /* fuer HZ */

    43

#include <linux/ipipe.h>

    44

    45

#include "msr_param.h"   //wird im Projektverzeichnis erwartet

    46

    47

//#include <msr_control.h>

    48

#include <msr_lists.h>

    49

#include <msr_charbuf.h>

    50

#include <msr_reg.h>

    51

#include <msr_error_reg.h>

    52

#include <msr_messages.h>

    53

#include <msr_proc.h>

    54

#include <msr_utils.h>

    55

#include <msr_main.h>

    56

    57

    58

#include <msr_float.h>

    59

    60

#include "../drivers/ec_master.h"

    61

#include "../drivers/ec_device.h"

    62

#include "../drivers/ec_types.h"

    63

#include "../drivers/ec_module.h"

    64

    65

#include "msr_jitter.h"

    66

    67

#define TSC2US(T) ((unsigned long) (T) * 1000UL / cpu_khz)

    68

    69

/*--external data------------------------------------------------------------*/

    70

    71

#define HZREDUCTION (MSR_ABTASTFREQUENZ/HZ)

    72

    73

extern wait_queue_head_t msr_read_waitqueue;

    74

    75

extern struct msr_char_buf *msr_kanal_puffer;

    76

    77

extern int proc_abtastfrequenz;

    78

    79

/*--local data---------------------------------------------------------------*/

    80

    81

extern struct timeval process_time;

    82

struct timeval msr_time_increment; // Increment per Interrupt

    83

    84

//adeos

    85

    86

static struct ipipe_domain this_domain;

    87

    88

static struct ipipe_sysinfo sys_info;

    89

    90

static EtherCAT_master_t *ecat_master = NULL;

    91

    92

static EtherCAT_slave_t ecat_slaves[] =

    93

{

    94

#if 1

    95

    // Block 1

    96

    ECAT_INIT_SLAVE(Beckhoff_EK1100, 0),

    97

    ECAT_INIT_SLAVE(Beckhoff_EL4102, 0),

    98

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 0),

    99

    ECAT_INIT_SLAVE(Beckhoff_EL3162, 0),

   100

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 0),

   101

    ECAT_INIT_SLAVE(Beckhoff_EL3102, 0),

   102

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 0),

   103

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 0),

   104

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 0),

   105

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 0),

   106

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 0),

   107

   108

    // Block 2

   109

    ECAT_INIT_SLAVE(Beckhoff_EK1100, 1),

   110

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1),

   111

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1),

   112

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1),

   113

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1),

   114

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1),

   115

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 1),

   116

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 1),

   117

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 1),

   118

    ECAT_INIT_SLAVE(Beckhoff_EL2004, 1),

   119

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1),

   120

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1),

   121

    ECAT_INIT_SLAVE(Beckhoff_EL1014, 1)

   122

#endif

   123

   124

#if 0

   125

    // Block 3

   126

   ,ECAT_INIT_SLAVE(Beckhoff_EK1100, 2),

   127

    ECAT_INIT_SLAVE(Beckhoff_EL3162, 2),

   128

    ECAT_INIT_SLAVE(Beckhoff_EL3162, 2),

   129

    ECAT_INIT_SLAVE(Beckhoff_EL3162, 2),

   130

    ECAT_INIT_SLAVE(Beckhoff_EL3162, 2),

   131

    ECAT_INIT_SLAVE(Beckhoff_EL3102, 2),

   132

    ECAT_INIT_SLAVE(Beckhoff_EL3102, 2),

   133

    ECAT_INIT_SLAVE(Beckhoff_EL3102, 2),

   134

    ECAT_INIT_SLAVE(Beckhoff_EL4102, 2),

   135

    ECAT_INIT_SLAVE(Beckhoff_EL4102, 2),

   136

    ECAT_INIT_SLAVE(Beckhoff_EL4102, 2),

   137

    ECAT_INIT_SLAVE(Beckhoff_EL4102, 2),

   138

    ECAT_INIT_SLAVE(Beckhoff_EL4132, 2)

   139

#endif

   140

};

   141

   142

#define ECAT_SLAVES_COUNT (sizeof(ecat_slaves) / sizeof(EtherCAT_slave_t))

   143

   144

#define USE_MSR_LIB

   145

   146

#ifdef USE_MSR_LIB

   147

double value;

   148

int dig1;

   149

#endif

   150

   151

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

   152

 *

   153

 * Function: next2004

   154

 *

   155

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

   156

   157

static int next2004(int *wrap)

   158

{

   159

    static int i = 0;

   160

    unsigned int j = 0;

   161

   162

    *wrap = 0;

   163

   164

    for (j = 0; j < ECAT_SLAVES_COUNT; j++)

   165

    {

   166

        i++;

   167

   168

        i %= ECAT_SLAVES_COUNT;

   169

   170

        if (i == 0) *wrap = 1;

   171

   172

        if (ecat_slaves[i].desc == Beckhoff_EL2004)

   173

        {

   174

            return i;

   175

        }

   176

    }

   177

   178

    return -1;

   179

}

   180

   181

   182

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

   183

 *

   184

 * Function: msr_controller_run()

   185

 *

   186

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

   187

   188

static void msr_controller_run(void)

   189

{

   190

    static int ms = 0;

   191

    static int cnt = 0;

   192

    static unsigned long int k = 0;

   193

    static int firstrun = 1;

   194

   195

    static int klemme = 0;

   196

    static int kanal = 0;

   197

    static int up_down = 0;

   198

    int wrap = 0;

   199

   200

    static unsigned int debug_counter = 0;

   201

    unsigned long t1, t2, t3, t4, t5, t6, t7;

   202

    static unsigned long lt = 0;

   203

    unsigned int tr1, tr2;

   204

   205

    rdtscl(t1);

   206

   207

    // Prozessdaten lesen

   208

    msr_jitter_run(MSR_ABTASTFREQUENZ);

   209

   210

    if (firstrun) klemme = next2004(&wrap);

   211

   212

    ms++;

   213

    ms %= 1000;

   214

    if (cnt++ > 200)

   215

    {

   216

        cnt = 0;

   217

   218

        if (++kanal > 3)

   219

        {

   220

            kanal = 0;

   221

            klemme = next2004(&wrap);

   222

   223

            if (wrap == 1)

   224

            {

   225

                if (up_down == 1) up_down = 0;

   226

                else up_down = 1;

   227

            }

   228

        }

   229

    }

   230

   231

    if (klemme >= 0) {

   232

        EtherCAT_write_value(&ecat_slaves[klemme], kanal, up_down);

   233

    }

   234

   235

#if 0

   236

    EtherCAT_write_value(&ecat_master->slaves[13], 1, ms > 500 ? 0 : 1);

   237

    EtherCAT_write_value(&ecat_master->slaves[14], 2, ms > 500 ? 0 : 1);

   238

    EtherCAT_write_value(&ecat_master->slaves[15], 3, ms > 500 ? 1 : 0);

   239

#endif

   240

   241

    // Prozessdaten schreiben

   242

    rdtscl(k);

   243

    rdtscl(t2);

   244

   245

    EtherCAT_process_data_cycle(ecat_master, 0);

   246

   247

    t3 = ecat_master->tx_time;

   248

    t4 = ecat_master->rx_time;

   249

    tr1 = ecat_master->rx_tries;

   250

   251

    EtherCAT_process_data_cycle(ecat_master, 1);

   252

   253

    t5 = ecat_master->tx_time;

   254

    t6 = ecat_master->rx_time;

   255

    tr2 = ecat_master->rx_tries;

   256

   257

    //EtherCAT_process_data_cycle(ecat_master, 2);

   258

   259

    // Daten lesen und skalieren

   260

#ifdef USE_MSR_LIB

   261

    value = EtherCAT_read_value(&ecat_slaves[5], 0) / 3276.0;

   262

    dig1 = EtherCAT_read_value(&ecat_slaves[2], 0);

   263

#endif

   264

   265

    rdtscl(t7);

   266

   267

    if (debug_counter == MSR_ABTASTFREQUENZ) {

   268

      printk(KERN_DEBUG "%lu: %luŽµs + %luŽµs + %luŽµs + %luŽµs + %luŽµs +"

   269

             " %luŽµs = %luŽµs (%u %u)\n",

   270

             TSC2US(t1 - lt),

   271

             TSC2US(t2 - t1), TSC2US(t3 - t2), TSC2US(t4 - t3),

   272

             TSC2US(t5 - t4), TSC2US(t6 - t5), TSC2US(t7 - t6),

   273

             TSC2US(t7 - t1), tr1, tr2);

   274

      debug_counter = 0;

   275

    }

   276

   277

    lt = t1;

   278

   279

    firstrun = 0;

   280

    debug_counter++;

   281

}

   282

   283

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

   284

 *

   285

 *  Function: msr_run(_interrupt)

   286

 *

   287

 *  Beschreibung: Routine wird zyklisch im Timerinterrupt ausgef�ührt

   288

 *                (hier mu�ß alles rein, was Echtzeit ist ...)

   289

 *

   290

 *  Parameter: Zeiger auf msr_data

   291

 *

   292

 *  R�ückgabe:

   293

 *

   294

 *  Status: exp

   295

 *

   296

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

   297

   298

void msr_run(unsigned irq)

   299

{

   300

  static int counter = 0;

   301

#ifdef USE_MSR_LIB

   302

   303

    timeval_add(&process_time,&process_time,&msr_time_increment);

   304

   305

    MSR_ADEOS_INTERRUPT_CODE(

   306

	msr_controller_run();

   307

	msr_write_kanal_list();

   308

	);

   309

#else

   310

    msr_controller_run();

   311

#endif

   312

    /* und wieder in die Timerliste eintragen */

   313

    /* und neu in die Taskqueue eintragen */

   314

    //timer.expires += 1;

   315

    //add_timer(&timer);

   316

   317

    ipipe_control_irq(irq,0,IPIPE_ENABLE_MASK);  //Interrupt bestŽätigen

   318

    if(counter++ > HZREDUCTION) {

   319

	ipipe_propagate_irq(irq);  //und weiterreichen

   320

	counter = 0;

   321

    }

   322

}

   323

   324

void domain_entry (void)

   325

{

   326

    printk("Domain %s started.\n", ipipe_current_domain->name);

   327

   328

    ipipe_get_sysinfo(&sys_info);

   329

    ipipe_virtualize_irq(ipipe_current_domain,sys_info.archdep.tmirq,

   330

			 &msr_run, NULL, IPIPE_HANDLE_MASK);

   331

   332

    ipipe_tune_timer(1000000000UL/MSR_ABTASTFREQUENZ,0);

   333

}

   334

   335

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

   336

 *

   337

 *  Function: msr_register_channels

   338

 *

   339

 *  Beschreibung: KanŽäle registrieren

   340

 *

   341

 *  Parameter:

   342

 *

   343

 *  RŽückgabe:

   344

 *

   345

 *  Status: exp

   346

 *

   347

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

   348

   349

int msr_globals_register(void)

   350

{

   351

#ifdef USE_MSR_LIB

   352

    msr_reg_kanal("/value", "V", &value, TDBL);

   353

    msr_reg_kanal("/dig1", "", &dig1, TINT);

   354

#endif

   355

#if 0

   356

    msr_reg_kanal("/Taskinfo/Ecat/TX-Delay","us",&ecat_tx_delay,TUINT);

   357

    msr_reg_kanal("/Taskinfo/Ecat/RX-Delay","us",&ecat_rx_delay,TUINT);

   358

    msr_reg_kanal("/Taskinfo/Ecat/TX-Cnt","",&tx_intr,TUINT);

   359

    msr_reg_kanal("/Taskinfo/Ecat/RX-Cnt","",&rx_intr,TUINT);

   360

    msr_reg_kanal("/Taskinfo/Ecat/Total-Cnt","",&total_intr,TUINT);

   361

#endif

   362

  return 0;

   363

}

   364

   365

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

   366

 * the init/clean material

   367

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

   368

   369

int __init init_module()

   370

{

   371

    unsigned int i;

   372

    struct ipipe_domain_attr attr; //ipipe

   373

   374

    // Als allererstes die RT-lib initialisieren

   375

#ifdef USE_MSR_LIB

   376

    if (msr_rtlib_init(1,MSR_ABTASTFREQUENZ,10,&msr_globals_register) < 0) {

   377

        msr_print_warn("msr_modul: can't initialize rtlib!");

   378

        goto out_return;

   379

    }

   380

#endif

   381

   382

    msr_jitter_init();

   383

   384

    printk(KERN_INFO "=== Starting EtherCAT environment... ===\n");

   385

   386

    if ((ecat_master = EtherCAT_request(0)) == NULL) {

   387

        printk(KERN_ERR "EtherCAT master 0 not available!\n");

   388

        goto out_msr_cleanup;

   389

    }

   390

   391

    printk("Checking EtherCAT slaves.\n");

   392

   393

    if (EtherCAT_check_slaves(ecat_master, ecat_slaves, ECAT_SLAVES_COUNT) != 0) {

   394

        printk(KERN_ERR "EtherCAT: Could not init slaves!\n");

   395

        goto out_release_master;

   396

    }

   397

   398

    printk("Activating all EtherCAT slaves.\n");

   399

   400

    for (i = 0; i < ECAT_SLAVES_COUNT; i++) {

   401

        if (EtherCAT_activate_slave(ecat_master, ecat_slaves + i) < 0) {

   402

            printk(KERN_ERR "EtherCAT: Could not activate slave %i!\n", i);

   403

            goto out_release_master;

   404

        }

   405

    }

   406

   407

    do_gettimeofday(&process_time);

   408

    msr_time_increment.tv_sec=0;

   409

    msr_time_increment.tv_usec=(unsigned int)(1000000/MSR_ABTASTFREQUENZ);

   410

   411

    ipipe_init_attr (&attr);

   412

    attr.name     = "IPIPE-MSR-MODULE";

   413

    attr.priority = IPIPE_ROOT_PRIO + 1;

   414

    attr.entry    = &domain_entry;

   415

    ipipe_register_domain(&this_domain,&attr);

   416

   417

    return 0;

   418

   419

 out_release_master:

   420

    EtherCAT_release(ecat_master);

   421

   422

 out_msr_cleanup:

   423

    msr_rtlib_cleanup();

   424

   425

 out_return:

   426

    return -1;

   427

}

   428

   429

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

   430

   431

void __exit cleanup_module()

   432

{

   433

    unsigned int i;

   434

   435

    msr_print_info("msk_modul: unloading...");

   436

   437

    ipipe_tune_timer(1000000000UL/HZ,0); //alten Timertakt wieder herstellen

   438

    ipipe_unregister_domain(&this_domain);

   439

   440

    if (ecat_master)

   441

    {

   442

        printk(KERN_INFO "=== Stopping EtherCAT environment... ===\n");

   443

   444

        printk(KERN_INFO "Deactivating slaves.\n");

   445

   446

        for (i = 0; i < ECAT_SLAVES_COUNT; i++) {

   447

            if (EtherCAT_deactivate_slave(ecat_master, ecat_slaves + i) < 0) {

   448

                printk(KERN_WARNING "Warning - Could not deactivate slave!\n");

   449

            }

   450

        }

   451

   452

        EtherCAT_release(ecat_master);

   453

   454

        printk(KERN_INFO "=== EtherCAT environment stopped. ===\n");

   455

    }

   456

   457

#ifdef USE_MSR_LIB

   458

    msr_rtlib_cleanup();

   459

#endif

   460

}

   461

   462

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

   463

   464

MODULE_LICENSE("GPL");

   465

MODULE_AUTHOR ("Wilhelm Hagemeister <hm@igh-essen.com>");

   466

MODULE_DESCRIPTION ("EtherCAT test environment");

   467

   468

module_init(init_module);

   469

module_exit(cleanup_module);

   470

   471

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