1

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

     2

 *

     3

 *  e c _ d e v i c e . c

     4

 *

     5

 *  Methoden für ein EtherCAT-Gerät.

     6

 *

     7

 *  $Date$

     8

 *  $Author$

     9

 *

    10

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

    11

    12

#include <linux/module.h>

    13

#include <linux/skbuff.h>

    14

#include <linux/if_ether.h>

    15

#include <linux/netdevice.h>

    16

#include <linux/delay.h>

    17

    18

#include "ec_device.h"

    19

    20

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

    21

    22

/**

    23

   EtherCAT-Geräte-Konstuktor.

    24

    25

   Initialisiert ein EtherCAT-Gerät, indem es die Variablen

    26

   in der Struktur auf die Default-Werte setzt.

    27

    28

   @param ecd Zu initialisierendes EtherCAT-Gerät

    29

*/

    30

    31

void EtherCAT_device_init(EtherCAT_device_t *ecd)

    32

{

    33

  ecd->dev = NULL;

    34

  ecd->tx_skb = NULL;

    35

  ecd->rx_skb = NULL;

    36

  ecd->tx_time = 0;

    37

  ecd->rx_time = 0;

    38

  ecd->tx_intr_cnt = 0;

    39

  ecd->rx_intr_cnt = 0;

    40

  ecd->intr_cnt = 0;

    41

  ecd->state = ECAT_DS_READY;

    42

  ecd->rx_data_length = 0;

    43

  ecd->isr = NULL;

    44

  ecd->module = NULL;

    45

}

    46

    47

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

    48

    49

/**

    50

   EtherCAT-Geräte-Destuktor.

    51

    52

   Gibt den dynamisch allozierten Speicher des

    53

   EtherCAT-Gerätes (die beiden Socket-Buffer) wieder frei.

    54

    55

   @param ecd EtherCAT-Gerät

    56

*/

    57

    58

void EtherCAT_device_clear(EtherCAT_device_t *ecd)

    59

{

    60

  ecd->dev = NULL;

    61

    62

  if (ecd->tx_skb)

    63

  {

    64

    dev_kfree_skb(ecd->tx_skb);

    65

    ecd->tx_skb = NULL;

    66

  }

    67

    68

  if (ecd->rx_skb)

    69

  {

    70

    dev_kfree_skb(ecd->rx_skb);

    71

    ecd->rx_skb = NULL;

    72

  }

    73

}

    74

    75

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

    76

    77

/**

    78

   Weist einem EtherCAT-Gerät das entsprechende net_device zu.

    79

    80

   Prüft das net_device, allokiert Socket-Buffer in Sende- und

    81

   Empfangsrichtung und weist dem EtherCAT-Gerät und den

    82

   Socket-Buffern das net_device zu.

    83

    84

   @param ecd EtherCAT-Device

    85

   @param dev net_device

    86

    87

   @return 0: Erfolg, < 0: Konnte Socket-Buffer nicht allozieren.

    88

*/

    89

    90

int EtherCAT_device_assign(EtherCAT_device_t *ecd,

    91

                           struct net_device *dev)

    92

{

    93

  if (!dev)

    94

  {

    95

    printk("EtherCAT: Device is NULL!\n");

    96

    return -1;

    97

  }

    98

    99

  if ((ecd->tx_skb = dev_alloc_skb(ECAT_FRAME_BUFFER_SIZE)) == NULL)

   100

  {

   101

    printk(KERN_ERR "EtherCAT: Could not allocate device tx socket buffer!\n");

   102

    return -1;

   103

  }

   104

   105

  if ((ecd->rx_skb = dev_alloc_skb(ECAT_FRAME_BUFFER_SIZE)) == NULL)

   106

  {

   107

    dev_kfree_skb(ecd->tx_skb);

   108

    ecd->tx_skb = NULL;

   109

   110

    printk(KERN_ERR "EtherCAT: Could not allocate device rx socket buffer!\n");

   111

    return -1;

   112

  }

   113

   114

  ecd->dev = dev;

   115

  ecd->tx_skb->dev = dev;

   116

  ecd->rx_skb->dev = dev;

   117

   118

  printk("EtherCAT: Assigned Device %X.\n", (unsigned) dev);

   119

   120

  return 0;

   121

}

   122

   123

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

   124

   125

/**

   126

   Führt die open()-Funktion des Netzwerktreibers aus.

   127

   128

   Dies entspricht einem "ifconfig up". Vorher wird der Zeiger

   129

   auf das EtherCAT-Gerät auf Gültigkeit geprüft und der

   130

   Gerätezustand zurückgesetzt.

   131

   132

   @param ecd EtherCAT-Gerät

   133

   134

   @return 0 bei Erfolg, < 0: Ungültiger Zeiger, oder open()

   135

   fehlgeschlagen

   136

*/

   137

   138

int EtherCAT_device_open(EtherCAT_device_t *ecd)

   139

{

   140

  if (!ecd)

   141

  {

   142

    printk(KERN_ERR "EtherCAT: Trying to open a NULL device!\n");

   143

    return -1;

   144

  }

   145

   146

  if (!ecd->dev)

   147

  {

   148

    printk(KERN_ERR "EtherCAT: No net_device to open!\n");

   149

    return -1;

   150

  }

   151

   152

  // Reset old device state

   153

  ecd->state = ECAT_DS_READY;

   154

  ecd->tx_intr_cnt = 0;

   155

  ecd->rx_intr_cnt = 0;

   156

   157

  return ecd->dev->open(ecd->dev);

   158

}

   159

   160

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

   161

   162

/**

   163

   Führt die stop()-Funktion des net_devices aus.

   164

   165

   @param ecd EtherCAT-Gerät

   166

   167

   @return 0 bei Erfolg, < 0: Kein Gerät zum Schliessen

   168

*/

   169

   170

int EtherCAT_device_close(EtherCAT_device_t *ecd)

   171

{

   172

  if (!ecd->dev)

   173

  {

   174

    printk("EtherCAT: No device to close!\n");

   175

    return -1;

   176

  }

   177

   178

  printk("EtherCAT: Stopping device (txcnt: %u, rxcnt: %u)\n",

   179

         (unsigned int) ecd->tx_intr_cnt,

   180

         (unsigned int) ecd->rx_intr_cnt);

   181

   182

  return ecd->dev->stop(ecd->dev);

   183

}

   184

   185

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

   186

   187

/**

   188

   Sendet einen Rahmen über das EtherCAT-Gerät.

   189

   190

   Kopiert die zu sendenden Daten in den statischen Socket-

   191

   Buffer, fügt den Ethernat-II-Header hinzu und ruft die

   192

   start_xmit()-Funktion der Netzwerkkarte auf.

   193

   194

   @param ecd EtherCAT-Gerät

   195

   @param data Zeiger auf die zu sendenden Daten

   196

   @param length Länge der zu sendenden Daten

   197

   198

   @return 0 bei Erfolg, < 0: Vorheriger Rahmen noch

   199

   nicht empfangen, oder kein Speicher mehr vorhanden

   200

*/

   201

   202

int EtherCAT_device_send(EtherCAT_device_t *ecd,

   203

                         unsigned char *data,

   204

                         unsigned int length)

   205

{

   206

  unsigned char *frame_data;

   207

  struct ethhdr *eth;

   208

   209

  if (ecd->state == ECAT_DS_SENT)

   210

  {

   211

    printk(KERN_WARNING "EtherCAT: Trying to send frame while last was not received!\n");

   212

  }

   213

   214

  skb_trim(ecd->tx_skb, 0); // Clear transmit socket buffer

   215

  skb_reserve(ecd->tx_skb, ETH_HLEN); // Reserve space for Ethernet-II header

   216

   217

  // Copy data to socket buffer

   218

  frame_data = skb_put(ecd->tx_skb, length);

   219

  memcpy(frame_data, data, length);

   220

   221

  // Add Ethernet-II-Header

   222

  if ((eth = (struct ethhdr *) skb_push(ecd->tx_skb, ETH_HLEN)) == NULL)

   223

  {

   224

    printk(KERN_ERR "EtherCAT: device_send - Could not allocate Ethernet-II header!\n");

   225

    return -1;

   226

  }

   227

   228

  eth->h_proto = htons(0x88A4); // Protocol type

   229

  memcpy(eth->h_source, ecd->dev->dev_addr, ecd->dev->addr_len); // Hardware address

   230

  memset(eth->h_dest, 0xFF, ecd->dev->addr_len); // Broadcast address

   231

   232

  rdtscl(ecd->tx_time); // Get CPU cycles

   233

   234

  // Start sending of frame

   235

  ecd->state = ECAT_DS_SENT;

   236

  ecd->dev->hard_start_xmit(ecd->tx_skb, ecd->dev);

   237

   238

  return 0;

   239

}

   240

   241

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

   242

   243

/**

   244

   Holt einen empfangenen Rahmen von der Netzwerkkarte.

   245

   246

   Zuerst wird geprüft, ob überhaupt ein Rahmen empfangen

   247

   wurde. Wenn ja, wird diesem mit Hilfe eines Spin-Locks

   248

   in den angegebenen Speicherbereich kopiert.

   249

   250

   @param ecd EtherCAT-Gerät

   251

   @param data Zeiger auf den Speicherbereich, in den die

   252

               empfangenen Daten kopiert werden sollen

   253

   254

   @return Anzahl der kopierten Bytes bei Erfolg, sonst < 0

   255

*/

   256

   257

int EtherCAT_device_receive(EtherCAT_device_t *ecd,

   258

                            unsigned char *data)

   259

{

   260

  if (ecd->state != ECAT_DS_RECEIVED)

   261

  {

   262

    printk(KERN_ERR "EtherCAT: receive - Nothing received!\n");

   263

    return -1;

   264

  }

   265

   266

  if (ecd->rx_data_length > ECAT_FRAME_BUFFER_SIZE)

   267

  {

   268

    printk(KERN_ERR "EtherCAT: receive - Reveived frame too long (%i Bytes)!\n",

   269

           ecd->rx_data_length);

   270

    return -1;

   271

  }

   272

   273

  memcpy(data, ecd->rx_data, ecd->rx_data_length);

   274

   275

  return ecd->rx_data_length;

   276

}

   277

   278

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

   279

   280

/**

   281

   Ruft manuell die Interrupt-Routine der Netzwerkkarte auf.

   282

   283

   @param ecd EtherCAT-Gerät

   284

   285

   @return Anzahl der kopierten Bytes bei Erfolg, sonst < 0

   286

*/

   287

   288

void EtherCAT_device_call_isr(EtherCAT_device_t *ecd)

   289

{

   290

    if (ecd->isr) ecd->isr(0, ecd->dev, NULL);

   291

}

   292

   293

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

   294

   295

/**

   296

   Gibt alle Informationen über das Device-Objekt aus.

   297

   298

   @param ecd EtherCAT-Gerät

   299

*/

   300

   301

void EtherCAT_device_debug(EtherCAT_device_t *ecd)

   302

{

   303

  printk(KERN_DEBUG "---EtherCAT device information begin---\n");

   304

   305

  if (ecd)

   306

  {

   307

    printk(KERN_DEBUG "Assigned net_device: %X\n", (unsigned) ecd->dev);

   308

    printk(KERN_DEBUG "Transmit socket buffer: %X\n", (unsigned) ecd->tx_skb);

   309

    printk(KERN_DEBUG "Receive socket buffer: %X\n", (unsigned) ecd->rx_skb);

   310

    printk(KERN_DEBUG "Time of last transmission: %u\n", (unsigned) ecd->tx_time);

   311

    printk(KERN_DEBUG "Time of last receive: %u\n", (unsigned) ecd->rx_time);

   312

    printk(KERN_DEBUG "Number of transmit interrupts: %u\n", (unsigned) ecd->tx_intr_cnt);

   313

    printk(KERN_DEBUG "Number of receive interrupts: %u\n", (unsigned) ecd->rx_intr_cnt);

   314

    printk(KERN_DEBUG "Total Number of interrupts: %u\n", (unsigned) ecd->intr_cnt);

   315

    printk(KERN_DEBUG "Actual device state: %i\n", (int) ecd->state);

   316

    printk(KERN_DEBUG "Receive buffer: %X\n", (unsigned) ecd->rx_data);

   317

    printk(KERN_DEBUG "Receive buffer fill state: %u/%u\n",

   318

           (unsigned) ecd->rx_data_length, ECAT_FRAME_BUFFER_SIZE);

   319

  }

   320

  else

   321

  {

   322

    printk(KERN_DEBUG "Device is NULL!\n");

   323

  }

   324

   325

  printk(KERN_DEBUG "---EtherCAT device information end---\n");

   326

}

   327

   328

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

   329

   330

EXPORT_SYMBOL(EtherCAT_device_init);

   331

EXPORT_SYMBOL(EtherCAT_device_clear);

   332

EXPORT_SYMBOL(EtherCAT_device_assign);

   333

EXPORT_SYMBOL(EtherCAT_device_open);

   334

EXPORT_SYMBOL(EtherCAT_device_close);

   335

   336

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