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 "module.h"

    29

#include "netdev.h"

    30

    31

/**

    32

 * EtherCAT frame to enable forwarding on EtherCAT Terminals

    33

 */

    34

static const u8 frameForwardEthernetFrames[] = {

    35

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

    36

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

    37

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

    38

	0x08,

    39

	0x00,

    40

	0x00, 0x00,

    41

	0x00, 0x01,

    42

	0x02, 0x00,

    43

	0x00, 0x00,

    44

	0x00, 0x00,

    45

	0x00, 0x00

    46

};

    47

    48

#define FIFO_LENGTH 64

    49

    50

static void ecdev_kfree_skb_any(struct sk_buff *skb)

    51

{

    52

	/* never release a skb in EtherCAT mode */

    53

}

    54

    55

static bool ecdev_carrier_ok(const struct net_device *const netdev)

    56

{

    57

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

    58

	return ecdev_get_link(priv->ecdev);

    59

}

    60

    61

static void ecdev_carrier_on(struct net_device *const netdev)

    62

{

    63

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

    64

	ecdev_set_link(priv->ecdev, 1);

    65

}

    66

    67

static void ecdev_carrier_off(struct net_device *const netdev)

    68

{

    69

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

    70

	ecdev_set_link(priv->ecdev, 0);

    71

}

    72

    73

static void ecdev_nop(struct net_device *const netdev)

    74

{

    75

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

    76

}

    77

    78

static void ecdev_tx_fifo_full(struct ccat_eth_priv *const priv,

    79

			       const struct ccat_eth_frame *const frame)

    80

{

    81

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

    82

}

    83

    84

static void unregister_ecdev(struct net_device *const netdev)

    85

{

    86

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

    87

	ecdev_close(priv->ecdev);

    88

	ecdev_withdraw(priv->ecdev);

    89

}

    90

    91

typedef void (*fifo_add_function) (struct ccat_eth_frame *,

    92

				   struct ccat_eth_dma_fifo *);

    93

    94

static void ccat_eth_rx_fifo_add(struct ccat_eth_frame *frame,

    95

				 struct ccat_eth_dma_fifo *fifo)

    96

{

    97

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

    98

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

    99

   100

	frame->received = 0;

   101

	iowrite32(addr_and_length, fifo->reg);

   102

}

   103

   104

static void ccat_eth_tx_fifo_add_free(struct ccat_eth_frame *frame,

   105

				      struct ccat_eth_dma_fifo *fifo)

   106

{

   107

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

   108

	frame->sent = 1;

   109

}

   110

   111

static void ccat_eth_tx_fifo_full(struct ccat_eth_priv *const priv,

   112

				  const struct ccat_eth_frame *const frame)

   113

{

   114

	priv->stop_queue(priv->netdev);

   115

	priv->next_tx_frame = frame;

   116

}

   117

   118

static void ccat_eth_dma_fifo_reset(struct ccat_eth_dma_fifo *fifo)

   119

{

   120

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

   121

	const struct ccat_eth_frame *const end = frame + FIFO_LENGTH;

   122

   123

	/* reset hw fifo */

   124

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

   125

	wmb();

   126

   127

	if (fifo->add) {

   128

		while (frame < end) {

   129

			fifo->add(frame, fifo);

   130

			++frame;

   131

		}

   132

	}

   133

}

   134

   135

static int ccat_eth_dma_fifo_init(struct ccat_eth_dma_fifo *fifo,

   136

				  void __iomem * const fifo_reg,

   137

				  fifo_add_function add, size_t channel,

   138

				  struct ccat_eth_priv *const priv)

   139

{

   140

	if (0 !=

   141

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

   142

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

   143

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

   144

		return -1;

   145

	}

   146

	fifo->add = add;

   147

	fifo->reg = fifo_reg;

   148

	return 0;

   149

}

   150

   151

/**

   152

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

   153

 */

   154

static void ccat_eth_priv_free_dma(struct ccat_eth_priv *priv)

   155

{

   156

	/* reset hw fifo's */

   157

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

   158

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

   159

	wmb();

   160

   161

	/* release dma */

   162

	ccat_dma_free(&priv->rx_fifo.dma);

   163

	ccat_dma_free(&priv->tx_fifo.dma);

   164

}

   165

   166

/**

   167

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

   168

 */

   169

static int ccat_eth_priv_init_dma(struct ccat_eth_priv *priv)

   170

{

   171

	if (ccat_eth_dma_fifo_init

   172

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

   173

	     priv->info.rx_dma_chan, priv)) {

   174

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

   175

		return -1;

   176

	}

   177

   178

	if (ccat_eth_dma_fifo_init

   179

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

   180

	     priv->info.tx_dma_chan, priv)) {

   181

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

   182

		ccat_dma_free(&priv->rx_fifo.dma);

   183

		return -1;

   184

	}

   185

   186

	/* disable MAC filter */

   187

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

   188

	wmb();

   189

	return 0;

   190

}

   191

   192

/**

   193

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

   194

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

   195

 */

   196

static void ccat_eth_priv_init_mappings(struct ccat_eth_priv *priv)

   197

{

   198

	struct ccat_mac_infoblock offsets;

   199

	void __iomem *const func_base =

   200

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

   201

   202

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

   203

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

   204

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

   205

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

   206

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

   207

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

   208

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

   209

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

   210

}

   211

   212

static netdev_tx_t ccat_eth_start_xmit(struct sk_buff *skb,

   213

				       struct net_device *dev)

   214

{

   215

	static size_t next = 0;

   216

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   217

	struct ccat_eth_frame *const frame =

   218

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

   219

	u32 addr_and_length;

   220

   221

	if (skb_is_nonlinear(skb)) {

   222

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

   223

		atomic64_inc(&priv->tx_dropped);

   224

		priv->kfree_skb_any(skb);

   225

		return NETDEV_TX_OK;

   226

	}

   227

   228

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

   229

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

   230

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

   231

		atomic64_inc(&priv->tx_dropped);

   232

		priv->kfree_skb_any(skb);

   233

		return NETDEV_TX_OK;

   234

	}

   235

   236

	if (!frame[next].sent) {

   237

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

   238

		ccat_eth_tx_fifo_full(priv, &frame[next]);

   239

		return NETDEV_TX_BUSY;

   240

	}

   241

   242

	/* prepare frame in DMA memory */

   243

	frame[next].sent = 0;

   244

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

   245

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

   246

   247

	priv->kfree_skb_any(skb);

   248

   249

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

   250

	addr_and_length +=

   251

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

   252

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

   253

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

   254

   255

	next = (next + 1) % FIFO_LENGTH;

   256

	/* stop queue if tx ring is full */

   257

	if (!frame[next].sent) {

   258

		ccat_eth_tx_fifo_full(priv, &frame[next]);

   259

	}

   260

	return NETDEV_TX_OK;

   261

}

   262

   263

/**

   264

 * Function to transmit a raw buffer to the network (f.e. frameForwardEthernetFrames)

   265

 * @dev a valid net_device

   266

 * @data pointer to your raw buffer

   267

 * @len number of bytes in the raw buffer to transmit

   268

 */

   269

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

   270

			      size_t len)

   271

{

   272

	struct sk_buff *skb = dev_alloc_skb(len);

   273

   274

	skb->dev = dev;

   275

	skb_copy_to_linear_data(skb, data, len);

   276

	skb_put(skb, len);

   277

	ccat_eth_start_xmit(skb, dev);

   278

}

   279

   280

static const size_t CCATRXDESC_HEADER_LEN = 20;

   281

static void ccat_eth_receive(struct net_device *const dev,

   282

			     const struct ccat_eth_frame *const frame)

   283

{

   284

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   285

	const size_t len = frame->length - CCATRXDESC_HEADER_LEN;

   286

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

   287

   288

	if (!skb) {

   289

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

   290

		atomic64_inc(&priv->rx_dropped);

   291

		return;

   292

	}

   293

	skb->dev = dev;

   294

	skb_reserve(skb, NET_IP_ALIGN);

   295

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

   296

	skb_put(skb, len);

   297

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

   298

	skb->ip_summed = CHECKSUM_UNNECESSARY;

   299

	atomic64_add(len, &priv->rx_bytes);

   300

	netif_rx(skb);

   301

}

   302

   303

static void ccat_eth_link_down(struct net_device *dev)

   304

{

   305

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   306

   307

	priv->stop_queue(dev);

   308

	priv->carrier_off(dev);

   309

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

   310

}

   311

   312

static void ccat_eth_link_up(struct net_device *const dev)

   313

{

   314

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   315

   316

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

   317

	/* TODO netdev_info(dev, "NIC Link is Up %u Mbps %s Duplex\n",

   318

	   speed == SPEED_100 ? 100 : 10,

   319

	   cmd.duplex == DUPLEX_FULL ? "Full" : "Half"); */

   320

   321

	ccat_eth_dma_fifo_reset(&priv->rx_fifo);

   322

	ccat_eth_dma_fifo_reset(&priv->tx_fifo);

   323

   324

	/* TODO reset CCAT MAC register */

   325

   326

	ccat_eth_xmit_raw(dev, frameForwardEthernetFrames,

   327

			  sizeof(frameForwardEthernetFrames));

   328

	priv->carrier_on(dev);

   329

	priv->start_queue(dev);

   330

}

   331

   332

/**

   333

 * Read link state from CCAT hardware

   334

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

   335

 */

   336

inline static size_t ccat_eth_priv_read_link_state(const struct ccat_eth_priv

   337

						   *const priv)

   338

{

   339

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

   340

}

   341

   342

/**

   343

 * Poll for link state changes

   344

 */

   345

static void poll_link(struct ccat_eth_priv *const priv)

   346

{

   347

	const size_t link = ccat_eth_priv_read_link_state(priv);

   348

   349

	if (link != priv->carrier_ok(priv->netdev)) {

   350

		if (link)

   351

			ccat_eth_link_up(priv->netdev);

   352

		else

   353

			ccat_eth_link_down(priv->netdev);

   354

	}

   355

}

   356

   357

/**

   358

 * Rx handler in EtherCAT operation mode

   359

 * priv->ecdev should always be valid!

   360

 */

   361

static void ec_poll_rx(struct net_device *dev)

   362

{

   363

	static size_t next = 0;

   364

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   365

	struct ccat_eth_frame *frame =

   366

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

   367

	if (frame->received) {

   368

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

   369

			      frame->length - CCATRXDESC_HEADER_LEN);

   370

		frame->received = 0;

   371

		ccat_eth_rx_fifo_add(frame, &priv->rx_fifo);

   372

		next = (next + 1) % FIFO_LENGTH;

   373

	} else {

   374

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

   375

	}

   376

}

   377

   378

/**

   379

 * Poll for available rx dma descriptors in ethernet operating mode

   380

 */

   381

static void poll_rx(struct ccat_eth_priv *const priv)

   382

{

   383

	struct ccat_eth_frame *const frame = priv->rx_fifo.dma.virt;

   384

	static size_t next = 0;

   385

   386

	/* TODO omit possible deadlock in situations with heavy traffic */

   387

	while (frame[next].received) {

   388

		ccat_eth_receive(priv->netdev, frame + next);

   389

		frame[next].received = 0;

   390

		ccat_eth_rx_fifo_add(frame + next, &priv->rx_fifo);

   391

		next = (next + 1) % FIFO_LENGTH;

   392

	}

   393

}

   394

   395

/**

   396

 * Poll for available tx dma descriptors in ethernet operating mode

   397

 */

   398

static void poll_tx(struct ccat_eth_priv *const priv)

   399

{

   400

	if (priv->next_tx_frame && priv->next_tx_frame->sent) {

   401

		priv->next_tx_frame = NULL;

   402

		netif_wake_queue(priv->netdev);

   403

	}

   404

}

   405

   406

/**

   407

 * Since CCAT doesn't support interrupts until now, we have to poll

   408

 * some status bits to recognize things like link change etc.

   409

 */

   410

static enum hrtimer_restart poll_timer_callback(struct hrtimer *timer)

   411

{

   412

	struct ccat_eth_priv *priv = container_of(timer, struct ccat_eth_priv,

   413

						  poll_timer);

   414

   415

	poll_link(priv);

   416

	if(!priv->ecdev)

   417

		poll_rx(priv);

   418

	poll_tx(priv);

   419

	hrtimer_forward_now(timer, ktime_set(0, 100 * NSEC_PER_USEC));

   420

	return HRTIMER_RESTART;

   421

}

   422

   423

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

   424

						      *storage)

   425

{

   426

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   427

	struct ccat_mac_register mac;

   428

   429

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

   430

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

   431

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

   432

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

   433

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

   434

	storage->rx_errors = mac.frame_len_err + mac.rx_mem_full + mac.crc_err + mac.rx_err;	/* bad packets received         */

   436

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

   437

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

   438

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

   439

	//TODO __u64    collisions;

   440

   441

	/* detailed rx_errors: */

   442

	storage->rx_length_errors = mac.frame_len_err;

   443

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

   444

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

   445

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

   446

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

   447

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

   448

   449

	/* detailed tx_errors */

   450

	//TODO __u64    tx_aborted_errors;

   451

	//TODO __u64    tx_carrier_errors;

   452

	//TODO __u64    tx_fifo_errors;

   453

	//TODO __u64    tx_heartbeat_errors;

   454

	//TODO __u64    tx_window_errors;

   455

   456

	/* for cslip etc */

   457

	//TODO __u64    rx_compressed;

   458

	//TODO __u64    tx_compressed;

   459

	return storage;

   460

}

   461

   462

static int ccat_eth_open(struct net_device *dev)

   463

{

   464

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   465

   466

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

   467

	priv->poll_timer.function = poll_timer_callback;

   468

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

   469

		      HRTIMER_MODE_REL);

   470

	return 0;

   471

}

   472

   473

static int ccat_eth_stop(struct net_device *dev)

   474

{

   475

	struct ccat_eth_priv *const priv = netdev_priv(dev);

   476

   477

	priv->stop_queue(dev);

   478

	hrtimer_cancel(&priv->poll_timer);

   479

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

   480

	return 0;

   481

}

   482

   483

static const struct net_device_ops ccat_eth_netdev_ops = {

   484

	.ndo_get_stats64 = ccat_eth_get_stats64,

   485

	.ndo_open = ccat_eth_open,

   486

	.ndo_start_xmit = ccat_eth_start_xmit,

   487

	.ndo_stop = ccat_eth_stop,

   488

};

   489

   490

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

   491

				    const void __iomem * const addr)

   492

{

   493

	struct ccat_eth_priv *priv;

   494