/******************************************************************************
 *
 * msr_io.c
 *
 * Sample Modul für EtherCAT
 *           
 * Autoren: Wilhelm Hagemeister, Florian Pose
 *
 * $Date$
 * $Author$
 *
 * (C) Copyright IgH 2005
 * Ingenieurgemeinschaft IgH
 * Heinz-Bäcker Str. 34
 * D-45356 Essen
 * Tel.: +49 201/61 99 31
 * Fax.: +49 201/61 98 36
 * E-mail: hm@igh-essen.com
 *
 * /bin/setserial /dev/ttyS0 uart none
 * /bin/setserial /dev/ttyS1 uart none
 *
 ******************************************************************************/

/*--Includes-----------------------------------------------------------------*/

#include <linux/module.h>
#include <linux/tqueue.h>
#include <linux/slab.h>
#include <linux/delay.h>

#include <msr_reg.h>
#include <msr_messages.h>
#include <msr_main.h>

#include <rtai.h>
#include <rtai_sched.h>

#include "msr_io.h"

//#include <msr_float.h>

#include "../drivers/ec_master.h"
#include "../drivers/ec_device.h"
#include "../drivers/ec_types.h"
#include "../rs232dbg/rs232dbg.h"

/*--Defines------------------------------------------------------------------*/

#define TIMERTICS 1e6	// in ns; Thus have a task time of 1ms
#define MSR_ABTASTFREQUENZ (1e9/TIMERTICS)

//#define MSR_ABTASTFREQUENZ (1000) //1e9/TIMERTICS)
#define TICK ((1000000 / MSR_ABTASTFREQUENZ) * 1000)
#define TIMER_FREQ (APIC_TIMER ? FREQ_APIC : FREQ_8254)
#define APIC_TIMER 0

//#define MSR_SLOW_DEBUG

/*--Globale Variablen--------------------------------------------------------*/

RT_TASK process_image;

const int Tick = TICK;

unsigned int ecat_tx_delay = 0; //Zeit vom Ende der TimerInterruptRoutine bis
                                //TX-Interrupt der Netzwerkkarte 
unsigned int ecat_rx_delay = 0; //RX-Interrupt der Netzwerkkarte

unsigned int tx_intr = 0;
unsigned int rx_intr = 0;
unsigned int total_intr = 0;

unsigned int thread_end = 0;

#define USE_ETHERCAT

#ifdef USE_ETHERCAT

static EtherCAT_master_t *ecat_master = NULL;

extern EtherCAT_device_t rtl_ecat_dev;

//#define ECAT_SLAVES_COUNT 16

static EtherCAT_slave_t ecat_slaves[] =
{
    //Block 1
  ECAT_INIT_SLAVE(Beckhoff_EK1100),
  ECAT_INIT_SLAVE(Beckhoff_EL4102),
  ECAT_INIT_SLAVE(Beckhoff_EL3162),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL3102),
  ECAT_INIT_SLAVE(Beckhoff_EL4102),
  ECAT_INIT_SLAVE(Beckhoff_EL4102),
  ECAT_INIT_SLAVE(Beckhoff_EL4102),
  ECAT_INIT_SLAVE(Beckhoff_EL3162),
  ECAT_INIT_SLAVE(Beckhoff_EL3162),
  ECAT_INIT_SLAVE(Beckhoff_EL3162),
  ECAT_INIT_SLAVE(Beckhoff_EL3102),
  ECAT_INIT_SLAVE(Beckhoff_EL3102),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  //Block 2
  ECAT_INIT_SLAVE(Beckhoff_EK1100),
  ECAT_INIT_SLAVE(Beckhoff_EL4102),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL3162),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL3102),
  //Block 3
  ECAT_INIT_SLAVE(Beckhoff_EK1100),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL2004),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL1014),
  ECAT_INIT_SLAVE(Beckhoff_EL1014)


};

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

#endif

double value;
int dig1;


static int next2004(int *wrap)
{
    static int i=0;

    int j=0;

    *wrap = 0;
    for(j=0;j<ECAT_SLAVES_COUNT;j++) {
	i++;
	i %= ECAT_SLAVES_COUNT;
	if(i == 0) *wrap = 1;
	if(ecat_slaves[i].desc == Beckhoff_EL2004) {
	    return i;
	}
    }
    return -1;
}

/*
*******************************************************************************
*
* Function: msr_controller
*
* Beschreibung: Zyklischer Prozess
*
* Parameter:
*
* Rückgabe: 
*               
* Status: exp
*
*******************************************************************************
*/

void msr_controller(void)
{
  static int ms = 0;
  static int cnt = 0;
  static unsigned long int k = 0;
  static int firstrun = 1;

  static int klemme = 12;
  static int kanal = 0;
  static int up_down = 0;
  int wrap = 0;

  ms++;
  ms %= 1000;

#ifdef USE_ETHERCAT
  ecat_tx_delay = ((unsigned int) (100000 / HZ) * (ecat_master->dev->tx_time-k))
    / (current_cpu_data.loops_per_jiffy / 10);  
  ecat_rx_delay = ((unsigned int) (100000 / HZ) * (ecat_master->dev->rx_time-k))
    / (current_cpu_data.loops_per_jiffy / 10);  

  rx_intr = ecat_master->dev->rx_intr_cnt;
  tx_intr = ecat_master->dev->tx_intr_cnt;
  total_intr = ecat_master->dev->intr_cnt;
  // Prozessdaten lesen
  if(!firstrun) {
      EtherCAT_read_process_data(ecat_master);

      // Daten lesen und skalieren
      value = EtherCAT_read_value(&ecat_master->slaves[5], 0) / 3276.7;
      dig1 = EtherCAT_read_value(&ecat_master->slaves[3], 0);
  }
  // Daten schreiben

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


   if(cnt++ > 20) {
      cnt = 0;
      if(++kanal > 3) {
	  kanal = 0;
	  klemme = next2004(&wrap);
	  if (wrap == 1) { 
	      if(up_down == 1) 
		  up_down = 0;
	      else up_down = 1;
	      }
	  }
      }
   if (klemme >=0)
    EtherCAT_write_value(&ecat_master->slaves[klemme], kanal,up_down);
  
//  EtherCAT_write_value(&ecat_master->slaves[13], 1, ms > 500 ? 0 : 1);
//  EtherCAT_write_value(&ecat_master->slaves[14], 2, ms > 500 ? 0 : 1);
//  EtherCAT_write_value(&ecat_master->slaves[15], 3, ms > 500 ? 1 : 0);

  // Prozessdaten schreiben
  rdtscl(k);
  EtherCAT_write_process_data(ecat_master);
  firstrun = 0;
#endif
}

/*
*******************************************************************************
*
* Function: msr_run_interrupt
*
* Beschreibung: Interrupt abarbeiten
*
* Parameter:
*
* Rückgabe: 
*               
* Status: exp
*
*******************************************************************************
*/

void process_thread(int priv_data)
{
  while (1)
  {

#ifdef USE_ETHERCAT
    MSR_RTAITHREAD_CODE(msr_controller(); msr_write_kanal_list(); );  
#else
    MSR_RTAITHREAD_CODE( msr_write_kanal_list(); );  
#endif



    /*   if(counter++ >=MSR_ABTASTFREQUENZ) {
	counter = 0;
	sprintf(buf,"rt:life");
	msr_print_info(buf);
    }
    */
    rt_task_wait_period();
  }
  thread_end = 1;
}

/*
*******************************************************************************
*
* Function: msr_register_channels
*
* Beschreibung: Kanäle registrieren
*
* Parameter:
*
* Rückgabe: 
*               
* Status: exp
*
*******************************************************************************
*/

int msr_globals_register(void)
{
  msr_reg_kanal("/value", "V", &value, TDBL);
  msr_reg_kanal("/dig1", "", &dig1, TINT);
  msr_reg_kanal("/Taskinfo/Ecat/TX-Delay","us",&ecat_tx_delay,TUINT);
  msr_reg_kanal("/Taskinfo/Ecat/RX-Delay","us",&ecat_rx_delay,TUINT);
  msr_reg_kanal("/Taskinfo/Ecat/TX-Cnt","",&tx_intr,TUINT);
  msr_reg_kanal("/Taskinfo/Ecat/RX-Cnt","",&rx_intr,TUINT);
  msr_reg_kanal("/Taskinfo/Ecat/Total-Cnt","",&total_intr,TUINT);

  return 0;
}

/*
*******************************************************************************
*
* Function: msr_init
*
* Beschreibung: MSR initialisieren
*
* Parameter:
*
* Rückgabe: 
*               
* Status: exp
*
*******************************************************************************
*/

int msr_init(void)
{   
  int rv = -1;
  RTIME tick_period, now;

//  rt_mount_rtai();

  msr_print_info("Initialising rtlib.");

  // RT-lib initialisieren    
  if (msr_rtlib_init(1, MSR_ABTASTFREQUENZ, 10, msr_globals_register) < 0)
  {
    msr_print_warn("msr_modul: can't initialize rtlib!");
    goto out_umount;
  }

#ifdef USE_ETHERCAT
  msr_print_info("Opening EtherCAT device.");

  mdelay(100);

  if (EtherCAT_device_open(&rtl_ecat_dev) < 0)
  {
    msr_print_warn("msr_modul: Could not initialize EtherCAT NIC.");
    goto out_rtlib;
  }

  if (!rtl_ecat_dev.dev) // Es gibt kein EtherCAT-Device
  {  
    msr_print_warn("msr_modul: No EtherCAT device!");
    goto out_close;
  }
//    goto out_close;

  // EtherCAT-Master und Slaves initialisieren

  msr_print_info("Initialising EtherCAT master");

  if ((ecat_master = (EtherCAT_master_t *) kmalloc(sizeof(EtherCAT_master_t), GFP_KERNEL)) == 0)
  {
    msr_print_warn(KERN_ERR "msr_modul: Could not alloc memory for EtherCAT master!\n");
    goto out_close;
  }

  if (EtherCAT_master_init(ecat_master, &rtl_ecat_dev) < 0)
  {
    msr_print_warn(KERN_ERR "EtherCAT could not init master!\n");
    goto out_master;
  }

  msr_print_info("Checking EtherCAT slaves.");
  mdelay(10); //Nachricht abwarten

  if (EtherCAT_check_slaves(ecat_master, ecat_slaves, ECAT_SLAVES_COUNT) != 0)
  {
    msr_print_warn(KERN_ERR "EtherCAT: Could not init slaves!\n");
    goto out_masterclear;
  }

  msr_print_info("Activating all EtherCAT slaves.");
  mdelay(10); //Nachricht abwarten

  if (EtherCAT_activate_all_slaves(ecat_master) != 0)
  {
    printk(KERN_ERR "EtherCAT: Could not activate slaves!\n");
    goto out_masterclear;
  }

  // Zyklischen Aufruf starten

#endif
  msr_print_info("Starting cyclic sample thread.");
  mdelay(10); //Nachricht abwarten

  EtherCAT_write_process_data(ecat_master);

  //mdelay(100);
  tick_period = start_rt_timer(nano2count(TIMERTICS));
  now = rt_get_time();

  if ((rv = rt_task_init(&process_image, process_thread, 0/*data*/, 64000/*stacksize*/, 0/*prio*/, 1/*use fpu*/, 0/*signal*/)))
  {
      msr_print_error("Could not initialise process_thread\n");
      goto out_stoptimer;
  }

  msr_print_info("Initialised sample thread\n");

  if ((rv = rt_task_make_periodic(&process_image, 
				  now + tick_period, 
				  tick_period)))
  {
      msr_print_error("Could not start process_thread\n");
      goto out_stoptask;
  }

  msr_print_info("Started sample thread.");

  return 0;

 out_stoptask:
  msr_print_info("Deleting task....");
  rt_task_delete(&process_image);

 out_stoptimer:
  msr_print_info("Stopping timer.");
  stop_rt_timer();

#ifdef USE_ETHERCAT
 out_masterclear:
  msr_print_info("Clearing EtherCAT master.");
  EtherCAT_master_clear(ecat_master);

 out_master:
    msr_print_info("Freeing EtherCAT master.");
  kfree(ecat_master);

 out_close:
  msr_print_info("Closing device.");

  EtherCAT_device_close(&rtl_ecat_dev);
#endif

 out_rtlib:
  msr_print_info("msr_rtlib_cleanup()");
  mdelay(10);
  msr_rtlib_cleanup();

 out_umount:
//  rt_umount_rtai();

  return rv;
}

/*
*******************************************************************************
*
* Function: msr_io_cleanup
*
* Beschreibung: Aufräumen
*
* Parameter:
*
* Rückgabe: 
*               
* Status: exp
*
*******************************************************************************
*/

void msr_io_cleanup(void)
{

  msr_print_info("Stopping timer.");

  stop_rt_timer();

  msr_print_info("Deleting task....");

  rt_task_delete(&process_image);
/*
  for(i=0;i<1000;i++) {
      udelay(100);
      if(thread_end == 1) {
	  msr_print_info("Task ended at count %d",i);
	  break;
      }
  }
*/
  //noch einmal lesen

  msr_print_info("Read Processdata");
  EtherCAT_read_process_data(ecat_master);

  //EtherCAT_read_process_data(ecat_master);
#ifdef USE_ETHERCAT
  if (ecat_master)
  {

    msr_print_info("Deactivating slaves.");


    EtherCAT_deactivate_all_slaves(ecat_master);    


    msr_print_info("Clearing EtherCAT master.");

    EtherCAT_master_clear(ecat_master);

    msr_print_info("Freeing EtherCAT master.");


    kfree(ecat_master);
    ecat_master = NULL;
  }

  msr_print_info("Closing device.");

  EtherCAT_device_close(&rtl_ecat_dev);

#endif
  msr_print_info("msr_rtlib_cleanup()");

  msr_rtlib_cleanup();
  //rt_umount_rtai();
}

/*---Treiber-Einsprungspunkte etc.-------------------------------------------*/

MODULE_LICENSE("GPL");

module_init(msr_init);
module_exit(msr_io_cleanup);

/*---Ende--------------------------------------------------------------------*/