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

    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

#include "ec_dbg.h"

    20

    21

extern irqreturn_t rtl8139_interrupt(int, void *, struct pt_regs *);

    22

extern int rtl8139_poll(struct net_device *, int *);

    23

    24

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

    25

    26

/**

    27

   EtherCAT-Geräte-Konstuktor.

    28

    29

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

    30

   in der Struktur auf die Default-Werte setzt.

    31

    32

   @param ecd Zu initialisierendes EtherCAT-Gerät

    33

*/

    34

    35

void EtherCAT_device_init(EtherCAT_device_t *ecd)

    36

{

    37

  ecd->dev = NULL;

    38

  ecd->tx_skb = NULL;

    39

  ecd->rx_skb = NULL;

    40

  ecd->tx_time = 0;

    41

  ecd->rx_time = 0;

    42

  ecd->tx_intr_cnt = 0;

    43

  ecd->rx_intr_cnt = 0;

    44

  ecd->intr_cnt = 0;

    45

  ecd->state = ECAT_DS_READY;

    46

  ecd->rx_data_length = 0;

    47

  ecd->lock = NULL;

    48

}

    49

    50

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

    51

    52

/**

    53

   EtherCAT-Geräte-Destuktor.

    54

    55

   Gibt den dynamisch allozierten Speicher des

    56

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

    57

    58

   @param ecd EtherCAT-Gerät

    59

*/

    60

    61

void EtherCAT_device_clear(EtherCAT_device_t *ecd)

    62

{

    63

  ecd->dev = NULL;

    64

    65

  if (ecd->tx_skb)

    66

  {

    67

    dev_kfree_skb(ecd->tx_skb);

    68

    ecd->tx_skb = NULL;

    69

  }

    70

    71

  if (ecd->rx_skb)

    72

  {

    73

    dev_kfree_skb(ecd->rx_skb);

    74

    ecd->rx_skb = NULL;

    75

  }

    76

}

    77

    78

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

    79

    80

/**

    81

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

    82

    83

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

    84

   Empfangsrichtung und weist dem EtherCAT-Gerät und den

    85

   Socket-Buffern das net_device zu.

    86

    87

   @param ecd EtherCAT-Device

    88

   @param dev net_device

    89

    90

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

    91

*/

    92

    93

int EtherCAT_device_assign(EtherCAT_device_t *ecd,

    94

                           struct net_device *dev)

    95

{

    96

  if (!dev)

    97

  {

    98

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

    99

    return -1;

   100

  }

   101

   102

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

   103

  {

   104

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

   105

    return -1;

   106

  }

   107

   108

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

   109

  {

   110

    dev_kfree_skb(ecd->tx_skb);

   111

    ecd->tx_skb = NULL;

   112

   113

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

   114

    return -1;

   115

  }

   116

   117

  ecd->dev = dev;

   118

  ecd->tx_skb->dev = dev;

   119

  ecd->rx_skb->dev = dev;

   120

   121

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

   122

   123

  return 0;

   124

}

   125

   126

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

   127

   128

/**

   129

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

   130

   131

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

   132

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

   133

   Gerätezustand zurückgesetzt.

   134

   135

   @param ecd EtherCAT-Gerät

   136

   137

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

   138

   fehlgeschlagen

   139

*/

   140

   141

int EtherCAT_device_open(EtherCAT_device_t *ecd)

   142

{

   143

  if (!ecd)

   144

  {

   145

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

   146

    return -1;

   147

  }

   148

   149

  if (!ecd->dev)

   150

  {

   151

    EC_DBG(KERN_ERR "EtherCAT: No device to open!\n");

   152

    return -1;

   153

  }

   154

   155

  // Reset old device state

   156

  ecd->state = ECAT_DS_READY;

   157

  ecd->tx_intr_cnt = 0;

   158

  ecd->rx_intr_cnt = 0;

   159

   160

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

   161

}

   162

   163

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

   164

   165

/**

   166

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

   167

   168

   @param ecd EtherCAT-Gerät

   169

   170

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

   171

*/

   172

   173

int EtherCAT_device_close(EtherCAT_device_t *ecd)

   174

{

   175

  if (!ecd->dev)

   176

  {

   177

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

   178

    return -1;

   179

  }

   180

   181

  EC_DBG("EtherCAT: txcnt: %u, rxcnt: %u\n",

   182

         (unsigned int) ecd->tx_intr_cnt,

   183

         (unsigned int) ecd->rx_intr_cnt);

   184

   185

  EC_DBG("EtherCAT: Stopping device at 0x%X\n",

   186

         (unsigned int) ecd->dev);

   187

   188

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

   189

}

   190

   191

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

   192

   193

/**

   194

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

   195

   196

   Kopiert die zu sendenden Daten in den statischen Socket-

   197

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

   198

   start_xmit()-Funktion der Netzwerkkarte auf.

   199

   200

   @param ecd EtherCAT-Gerät

   201

   @param data Zeiger auf die zu sendenden Daten

   202

   @param length Länge der zu sendenden Daten

   203

   204

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

   205

   nicht empfangen, oder kein Speicher mehr vorhanden

   206

*/

   207

   208

int EtherCAT_device_send(EtherCAT_device_t *ecd,

   209

                         unsigned char *data,

   210

                         unsigned int length)

   211

{

   212

  unsigned char *frame_data;

   213

  struct ethhdr *eth;

   214

   215

  if (ecd->state == ECAT_DS_SENT)

   216

  {

   217

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

   218

  }

   219

   220

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

   221

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

   222

   223

  // Copy data to socket buffer

   224

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

   225

  memcpy(frame_data, data, length);

   226

   227

  // Add Ethernet-II-Header

   228

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

   229

  {

   230

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

   231

    return -1;

   232

  }

   233

   234

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

   235

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

   236

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

   237

   238

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

   239

   240

  // Start sending of frame

   241

  ecd->state = ECAT_DS_SENT;

   242

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

   243

   244

  return 0;

   245

}

   246

   247

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

   248

   249

/**

   250

   Holt einen empfangenen Rahmen von der Netzwerkkarte.

   251

   252

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

   253

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

   254

   in den angegebenen Speicherbereich kopiert.

   255

   256

   @param ecd EtherCAT-Gerät

   257

   @param data Zeiger auf den Speicherbereich, in den die

   258

               empfangenen Daten kopiert werden sollen

   259

   260

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

   261

*/

   262

   263

int EtherCAT_device_receive(EtherCAT_device_t *ecd,

   264

                            unsigned char *data)

   265

{

   266

  if (ecd->state != ECAT_DS_RECEIVED)

   267

  {

   268

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

   269

    return -1;

   270

  }

   271

   272

  if (ecd->rx_data_length > ECAT_FRAME_BUFFER_SIZE)

   273

  {

   274

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

   275

           ecd->rx_data_length);

   276

    return -1;

   277

  }

   278

   279

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

   280

   281

  return ecd->rx_data_length;

   282

}

   283

   284

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

   285

   286

/**

   287

   Ruft manuell die Interrupt-Routine der Netzwerkkarte auf.

   288

   289

   @param ecd EtherCAT-Gerät

   290

   291

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

   292

*/

   293

   294

void EtherCAT_device_call_isr(EtherCAT_device_t *ecd)

   295

{

   296

    int budget;

   297

   298

    budget = 1; /* Einen Frame empfangen */

   299

   300

    rtl8139_interrupt(0, ecd->dev, NULL);

   302

    rtl8139_poll(ecd->dev, &budget);

   303

   305

    if (budget != 0)

   306

    {

   307

        EC_DBG(KERN_ERR "EtherCAT: Warning - Budget is %d!\n",

   308

               budget);

   309

    }

   311

}

   312

   313

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

   314

   315

/**

   316

   Gibt alle Informationen über das Device-Objekt aus.

   317

   318

   @param ecd EtherCAT-Gerät

   319

*/

   320

   321

void EtherCAT_device_debug(EtherCAT_device_t *ecd)

   322

{

   323

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

   324

   325

  if (ecd)

   326

  {

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   336

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

   337

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

   338

           (unsigned) ecd->rx_data_length, ECAT_FRAME_BUFFER_SIZE);

   339

    EC_DBG(KERN_DEBUG "Lock: %X\n", (unsigned) ecd->lock);

   340

  }

   341

  else

   342

  {

   343

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

   344

  }

   345

   346

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

   347

}

   348

   354

EXPORT_SYMBOL(EtherCAT_device_debug);

   355