1

/**

     2

    Network Driver for Beckhoff CCAT communication controller

     3

    Copyright (C) 2014  Beckhoff Automation GmbH

     4

    Author: Patrick Bruenn <p.bruenn@beckhoff.com>

     5

     6

    This program is free software; you can redistribute it and/or modify

     7

    it under the terms of the GNU General Public License as published by

     8

    the Free Software Foundation; either version 2 of the License, or

     9

    (at your option) any later version.

    10

    11

    This program is distributed in the hope that it will be useful,

    12

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    13

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14

    GNU General Public License for more details.

    15

    16

    You should have received a copy of the GNU General Public License along

    17

    with this program; if not, write to the Free Software Foundation, Inc.,

    18

    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

    19

*/

    20

    21

#include <linux/etherdevice.h>

    22

#include <linux/init.h>

    23

#include <linux/kernel.h>

    24

#include <linux/module.h>

    25

#include <linux/netdevice.h>

    26

#include <linux/spinlock.h>

    27

    28

#include "compat.h"

    29

#include "module.h"

    30

#include "netdev.h"

    31

#include "print.h"

    32

    33

/**

    34

 * EtherCAT frame to enable forwarding on EtherCAT Terminals

    35

 */

    36

static const u8 frameForwardEthernetFrames[] = {

    37

	0x01, 0x01, 0x05, 0x01, 0x00, 0x00,

    38

	0x00, 0x1b, 0x21, 0x36, 0x1b, 0xce,

    39

	0x88, 0xa4, 0x0e, 0x10,

    40

	0x08,

    41

	0x00,

    42

	0x00, 0x00,

    43

	0x00, 0x01,

    44

	0x02, 0x00,

    45

	0x00, 0x00,

    46

	0x00, 0x00,

    47

	0x00, 0x00

    48

};

    49

    50

#define FIFO_LENGTH 64

    51

static void ec_poll(struct net_device *dev);

    52

static enum hrtimer_restart poll_timer_callback(struct hrtimer *timer);

    53

    54

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)

    55

static struct rtnl_link_stats64 *ccat_eth_get_stats64(struct net_device *dev, struct rtnl_link_stats64

    56

						      *storage);

    57

#endif

    58

static int ccat_eth_open(struct net_device *dev);

    59

static netdev_tx_t ccat_eth_start_xmit(struct sk_buff *skb,

    60

				       struct net_device *dev);

    61

static int ccat_eth_stop(struct net_device *dev);

    62

static void ccat_eth_xmit_raw(struct net_device *dev, const char *data,

    63

			      size_t len);

    64

    65

static const struct net_device_ops ccat_eth_netdev_ops = {

    66

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)

    67

	.ndo_get_stats64 = ccat_eth_get_stats64,

    68

#endif

    69

	.ndo_open = ccat_eth_open,

    70

	.ndo_start_xmit = ccat_eth_start_xmit,

    71

	.ndo_stop = ccat_eth_stop,

    72

};

    73

    74

static void ecdev_kfree_skb_any(struct sk_buff *skb)

    75

{

    76

	/* never release a skb in EtherCAT mode */

    77

}

    78

    79

static bool ecdev_carrier_ok(struct net_device *const netdev)

    80

{

    81

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

    82

	return ecdev_get_link(priv->ecdev);

    83

}

    84

    85

static void ecdev_carrier_on(struct net_device *const netdev)

    86

{

    87

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

    88

	ecdev_set_link(priv->ecdev, 1);

    89

}

    90

    91

static void ecdev_carrier_off(struct net_device *const netdev)

    92

{

    93

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

    94

	ecdev_set_link(priv->ecdev, 0);

    95

}

    96

    97

static void ecdev_nop(struct net_device *const netdev)

    98

{

    99

	/* dummy called if nothing has to be done in EtherCAT operation mode */

   100

}

   101

   102

static void ecdev_tx_fifo_full(struct ccat_eth_priv *const priv,

   103

			       const struct ccat_eth_frame *const frame)

   104

{

   105

	/* we are polled -> there is nothing we can do in EtherCAT mode */

   106

}

   107

   108

static void unregister_ecdev(struct net_device *const netdev)

   109

{

   110

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   111

	ecdev_close(priv->ecdev);

   112

	ecdev_withdraw(priv->ecdev);

   113

}

   114

   115

typedef void (*fifo_add_function) (struct ccat_eth_frame *,

   116

				   struct ccat_eth_dma_fifo *);

   117

   118

static void ccat_eth_rx_fifo_add(struct ccat_eth_frame *frame,

   119

				 struct ccat_eth_dma_fifo *fifo)

   120

{

   121

	const size_t offset = ((void *)(frame) - fifo->dma.virt);

   122

	const u32 addr_and_length = (1 << 31) | offset;

   123

   124

	frame->received = 0;

   125

	iowrite32(addr_and_length, fifo->reg);

   126

}

   127

   128

static void ccat_eth_tx_fifo_add_free(struct ccat_eth_frame *frame,

   129

				      struct ccat_eth_dma_fifo *fifo)

   130

{

   131

	/* mark frame as ready to use for tx */

   132

	frame->sent = 1;

   133

}

   134

   135

static void ccat_eth_tx_fifo_full(struct ccat_eth_priv *const priv,

   136

				  const struct ccat_eth_frame *const frame)

   137

{

   138

	priv->stop_queue(priv->netdev);

   139

	priv->next_tx_frame = frame;

   140

}

   141

   142

static void ccat_eth_dma_fifo_reset(struct ccat_eth_dma_fifo *fifo)

   143

{

   144

	struct ccat_eth_frame *frame = fifo->dma.virt;

   145

	const struct ccat_eth_frame *const end = frame + FIFO_LENGTH;

   146

   147

	/* reset hw fifo */

   148

	iowrite32(0, fifo->reg + 0x8);

   149

	wmb();

   150

   151

	if (fifo->add) {

   152

		while (frame < end) {

   153

			fifo->add(frame, fifo);

   154

			++frame;

   155

		}

   156

	}

   157

}

   158

   159

static int ccat_eth_dma_fifo_init(struct ccat_eth_dma_fifo *fifo,

   160

				  void __iomem * const fifo_reg,

   161

				  fifo_add_function add, size_t channel,

   162

				  struct ccat_eth_priv *const priv)

   163

{

   164

	if (0 !=

   165

	    ccat_dma_init(&fifo->dma, channel, priv->ccatdev->bar[2].ioaddr,

   166

			  &priv->ccatdev->pdev->dev)) {

   167

		pr_info("init DMA%llu memory failed.\n", (u64) channel);

   168

		return -1;

   169

	}

   170

	fifo->add = add;

   171

	fifo->reg = fifo_reg;

   172

	return 0;

   173

}

   174

   175

/**

   176

 * Stop both (Rx/Tx) DMA fifo's and free related management structures

   177

 */

   178

static void ccat_eth_priv_free_dma(struct ccat_eth_priv *priv)

   179

{

   180

	/* reset hw fifo's */

   181

	iowrite32(0, priv->rx_fifo.reg + 0x8);

   182

	iowrite32(0, priv->tx_fifo.reg + 0x8);

   183

	wmb();

   184

   185

	/* release dma */

   186

	ccat_dma_free(&priv->rx_fifo.dma);

   187

	ccat_dma_free(&priv->tx_fifo.dma);

   188

}

   189

   190

/**

   191

 * Initalizes both (Rx/Tx) DMA fifo's and related management structures

   192

 */

   193

static int ccat_eth_priv_init_dma(struct ccat_eth_priv *priv)

   194

{

   195

	if (ccat_eth_dma_fifo_init

   196

	    (&priv->rx_fifo, priv->reg.rx_fifo, ccat_eth_rx_fifo_add,

   197

	     priv->info.rxDmaChn, priv)) {

   198

		pr_warn("init Rx DMA fifo failed.\n");

   199

		return -1;

   200

	}

   201

   202

	if (ccat_eth_dma_fifo_init

   203

	    (&priv->tx_fifo, priv->reg.tx_fifo, ccat_eth_tx_fifo_add_free,

   204

	     priv->info.txDmaChn, priv)) {

   205

		pr_warn("init Tx DMA fifo failed.\n");

   206

		ccat_dma_free(&priv->rx_fifo.dma);

   207

		return -1;

   208

	}

   209

   210

	/* disable MAC filter */

   211

	iowrite8(0, priv->reg.mii + 0x8 + 6);

   212

	wmb();

   213

	return 0;

   214

}

   215

   216

/**

   217

 * Initializes the CCat... members of the ccat_eth_priv structure.

   218

 * Call this function only if info and ioaddr are already initialized!

   219

 */

   220

static void ccat_eth_priv_init_mappings(struct ccat_eth_priv *priv)

   221

{

   222

	CCatInfoBlockOffs offsets;

   223

	void __iomem *const func_base =

   224

	    priv->ccatdev->bar[0].ioaddr + priv->info.nAddr;

   225

   226

	memcpy_fromio(&offsets, func_base, sizeof(offsets));

   227

	priv->reg.mii = func_base + offsets.nMMIOffs;

   228

	priv->reg.tx_fifo = func_base + offsets.nTxFifoOffs;

   229

	priv->reg.rx_fifo = func_base + offsets.nTxFifoOffs + 0x10;

   230

	priv->reg.mac = func_base + offsets.nMacRegOffs;

   231

	priv->reg.rx_mem = func_base + offsets.nRxMemOffs;

   232

	priv->reg.tx_mem = func_base + offsets.nTxMemOffs;

   233

	priv->reg.misc = func_base + offsets.nMiscOffs;

   234

}

   235

   236

/**

   237

 * Read link state from CCAT hardware

   238

 * @return 1 if link is up, 0 if not

   239

 */

   240

inline static size_t ccat_eth_priv_read_link_state(const struct ccat_eth_priv

   241

						   *const priv)

   242

{

   243

	return (1 << 24) == (ioread32(priv->reg.mii + 0x8 + 4) & (1 << 24));

   244

}

   245

   246

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)

   247

static struct rtnl_link_stats64 *ccat_eth_get_stats64(struct net_device *dev, struct rtnl_link_stats64

   248

						      *storage)

   249

{

   250

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   251

	CCatMacRegs mac;

   252

   253

	memcpy_fromio(&mac, priv->reg.mac, sizeof(mac));

   254

	storage->rx_packets = mac.rxFrameCnt;	/* total packets received       */

   255

	storage->tx_packets = mac.txFrameCnt;	/* total packets transmitted    */

   256

	storage->rx_bytes = atomic64_read(&priv->rx_bytes);	/* total bytes received         */

   257

	storage->tx_bytes = atomic64_read(&priv->tx_bytes);	/* total bytes transmitted      */

   258

	storage->rx_errors = mac.frameLenErrCnt + mac.dropFrameErrCnt + mac.crcErrCnt + mac.rxErrCnt;	/* bad packets received         */

   259

	//TODO __u64    tx_errors;              /* packet transmit problems     */

   260

	storage->rx_dropped = atomic64_read(&priv->rx_dropped);	/* no space in linux buffers    */

   261

	storage->tx_dropped = atomic64_read(&priv->tx_dropped);	/* no space available in linux  */

   262

	//TODO __u64    multicast;              /* multicast packets received   */

   263

	//TODO __u64    collisions;

   264

   265

	/* detailed rx_errors: */

   266

	storage->rx_length_errors = mac.frameLenErrCnt;

   267

	storage->rx_over_errors = mac.dropFrameErrCnt;	/* receiver ring buff overflow  */

   268

	storage->rx_crc_errors = mac.crcErrCnt;	/* recved pkt with crc error    */

   269

	storage->rx_frame_errors = mac.rxErrCnt;	/* recv'd frame alignment error */

   270

	storage->rx_fifo_errors = mac.dropFrameErrCnt;	/* recv'r fifo overrun          */

   271

	//TODO __u64    rx_missed_errors;       /* receiver missed packet       */

   272

   273

	/* detailed tx_errors */

   274

	//TODO __u64    tx_aborted_errors;

   275

	//TODO __u64    tx_carrier_errors;

   276

	//TODO __u64    tx_fifo_errors;

   277

	//TODO __u64    tx_heartbeat_errors;

   278

	//TODO __u64    tx_window_errors;

   279

   280

	/* for cslip etc */

   281

	//TODO __u64    rx_compressed;

   282

	//TODO __u64    tx_compressed;

   283

	return storage;

   284

}

   285

#endif

   286

   287

struct ccat_eth_priv *ccat_eth_init(const struct ccat_device *const ccatdev,

   288

				    const void __iomem * const addr)

   289

{

   290

	struct ccat_eth_priv *priv;

   291

	struct net_device *const netdev = alloc_etherdev(sizeof(*priv));

   292

   293

	priv = netdev_priv(netdev);

   294

	priv->netdev = netdev;

   295

	priv->ccatdev = ccatdev;

   296

   297

	/* ccat register mappings */

   298

	memcpy_fromio(&priv->info, addr, sizeof(priv->info));

   299

	ccat_eth_priv_init_mappings(priv);

   300

	ccat_print_function_info(priv);

   301

   302

	if (ccat_eth_priv_init_dma(priv)) {

   303

		pr_warn("%s(): DMA initialization failed.\n", __FUNCTION__);

   304

		free_netdev(netdev);

   305

		return NULL;

   306

	}

   307

   308

	/* init netdev with MAC and stack callbacks */

   309

	memcpy_fromio(netdev->dev_addr, priv->reg.mii + 8, 6);

   310

	netdev->netdev_ops = &ccat_eth_netdev_ops;

   311

   312

	/* use as EtherCAT device? */

   313

	priv->ecdev = ecdev_offer(netdev, ec_poll, THIS_MODULE);

   314

	if (priv->ecdev) {

   315

		priv->carrier_off = ecdev_carrier_off;

   316

		priv->carrier_ok = ecdev_carrier_ok;

   317

		priv->carrier_on = ecdev_carrier_on;

   318

		priv->kfree_skb_any = ecdev_kfree_skb_any;

   319

		priv->start_queue = ecdev_nop;

   320

		priv->stop_queue = ecdev_nop;

   321

		priv->tx_fifo_full = ecdev_tx_fifo_full;

   322

		priv->unregister = unregister_ecdev;

   325

		if (ecdev_open(priv->ecdev)) {

   326

			pr_info("unable to register network device.\n");

   327

			ecdev_withdraw(priv->ecdev);

   328

			ccat_eth_priv_free_dma(priv);

   329

			free_netdev(netdev);

   330

			return NULL;

   331

		}

   332

		return priv;

   333

	}

   334

   335

	/* EtherCAT disabled -> prepare normal ethernet mode */

   336

	priv->carrier_off = netif_carrier_off;

   337

	priv->carrier_ok = netif_carrier_ok;

   338

	priv->carrier_on = netif_carrier_on;

   339

	priv->kfree_skb_any = dev_kfree_skb_any;

   340

	priv->start_queue = netif_start_queue;

   341

	priv->stop_queue = netif_stop_queue;

   342

	priv->tx_fifo_full = ccat_eth_tx_fifo_full;

   343

	priv->unregister = unregister_netdev;

   346

	if (register_netdev(netdev)) {

   347

		pr_info("unable to register network device.\n");

   348

		ccat_eth_priv_free_dma(priv);

   349

		free_netdev(netdev);

   350

		return NULL;

   351

	}

   352

	pr_info("registered %s as network device.\n", netdev->name);

   353

	return priv;

   354

}

   355

   356

void ccat_eth_remove(struct ccat_eth_priv *const priv)

   357

{

   358

	priv->unregister(priv->netdev);

   359

	ccat_eth_priv_free_dma(priv);

   360

	free_netdev(priv->netdev);

   361

	pr_debug("%s(): done\n", __FUNCTION__);

   362

}

   363

   364

static int ccat_eth_open(struct net_device *dev)

   365

{

   366

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   367

   368

	hrtimer_init(&priv->poll_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

   369

	priv->poll_timer.function = poll_timer_callback;

   370

	hrtimer_start(&priv->poll_timer, ktime_set(0, 100000),

   371

		      HRTIMER_MODE_REL);

   372

	return 0;

   373

}

   374

   375

static const size_t CCATRXDESC_HEADER_LEN = 20;

   376

static void ccat_eth_receive(struct net_device *const dev,

   377

			     const struct ccat_eth_frame *const frame)

   378

{

   379

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   380

	const size_t len = frame->length - CCATRXDESC_HEADER_LEN;

   381

	struct sk_buff *skb = dev_alloc_skb(len + NET_IP_ALIGN);

   382

   383

	if (!skb) {

   384

		pr_info("%s() out of memory :-(\n", __FUNCTION__);

   385

		atomic64_inc(&priv->rx_dropped);

   386

		return;

   387

	}

   388

	skb->dev = dev;

   389

	skb_reserve(skb, NET_IP_ALIGN);

   390

	skb_copy_to_linear_data(skb, frame->data, len);

   391

	skb_put(skb, len);

   392

	skb->protocol = eth_type_trans(skb, dev);

   393

	skb->ip_summed = CHECKSUM_UNNECESSARY;

   394

	atomic64_add(len, &priv->rx_bytes);

   395

	netif_rx(skb);

   396

}

   397

   398

/**

   399

 * Rx handler in EtherCAT operation mode

   400

 * priv->ecdev should always be valid!

   401

 */

   402

static void ec_poll(struct net_device *dev)

   403

{

   404

	static size_t next = 0;

   405

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   406

	struct ccat_eth_frame *frame =

   407

	    ((struct ccat_eth_frame *)priv->rx_fifo.dma.virt) + next;

   408

	if (frame->received) {

   409

		ecdev_receive(priv->ecdev, frame->data,

   410

			      frame->length - CCATRXDESC_HEADER_LEN);

   411

		frame->received = 0;

   412

		ccat_eth_rx_fifo_add(frame, &priv->rx_fifo);

   413

		next = (next + 1) % FIFO_LENGTH;

   414

	} else {

   415

		//TODO dev_warn(&dev->dev, "%s(): frame was not ready\n", __FUNCTION__);

   416

	}

   417

}

   418

   419

static netdev_tx_t ccat_eth_start_xmit(struct sk_buff *skb,

   420

				       struct net_device *dev)

   421

{

   422

	static size_t next = 0;

   423

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   424

	struct ccat_eth_frame *const frame =

   425

	    ((struct ccat_eth_frame *)priv->tx_fifo.dma.virt);

   426

	u32 addr_and_length;

   427

   428

	if (skb_is_nonlinear(skb)) {

   429

		pr_warn("Non linear skb not supported -> drop frame.\n");

   430

		atomic64_inc(&priv->tx_dropped);

   431

		priv->kfree_skb_any(skb);

   432

		return NETDEV_TX_OK;

   433

	}

   434

   435

	if (skb->len > sizeof(frame->data)) {

   436

		pr_warn("skb.len %llu exceeds dma buffer %llu -> drop frame.\n",

   437

			(u64) skb->len, (u64) sizeof(frame->data));

   438

		atomic64_inc(&priv->tx_dropped);

   439

		priv->kfree_skb_any(skb);

   440

		return NETDEV_TX_OK;

   441

	}

   442

   443

	if (!frame[next].sent) {

   444

		netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");

   445

		ccat_eth_tx_fifo_full(priv, &frame[next]);

   446

		return NETDEV_TX_BUSY;

   447

	}

   448

   449

	/* prepare frame in DMA memory */

   450

	frame[next].sent = 0;

   451

	frame[next].length = skb->len;

   452

	memcpy(frame[next].data, skb->data, skb->len);

   453

   454

	priv->kfree_skb_any(skb);

   455

   456

	addr_and_length = 8 + (next * sizeof(*frame));

   457

	addr_and_length +=

   458

	    ((frame[next].length + CCAT_DMA_FRAME_HEADER_LENGTH) / 8) << 24;

   459

	iowrite32(addr_and_length, priv->reg.tx_fifo);	/* add to DMA fifo */

   460

	atomic64_add(frame[next].length, &priv->tx_bytes);	/* update stats */

   461

   462

	next = (next + 1) % FIFO_LENGTH;

   463

	/* stop queue if tx ring is full */

   464

	if (!frame[next].sent) {

   465

		ccat_eth_tx_fifo_full(priv, &frame[next]);

   466

	}

   467

	return NETDEV_TX_OK;

   468

}

   469

   470

static int ccat_eth_stop(struct net_device *dev)

   471

{

   472

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   473

   474

	priv->stop_queue(dev);

   475

	hrtimer_cancel(&priv->poll_timer);

   476

	netdev_info(dev, "stopped.\n");

   477

	return 0;

   478

}

   479

   480

static void ccat_eth_link_down(struct net_device *dev)

   481

{

   482

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   483

   484

	priv->stop_queue(dev);

   485

	priv->carrier_off(dev);

   486

	netdev_info(dev, "NIC Link is Down\n");

   487

}

   488

   489

static void ccat_eth_link_up(struct net_device *const dev)

   490

{

   491

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   492