1

/**

     2

    Network Driver for Beckhoff CCAT communication controller

     3

    Copyright (C) 2014 - 2015  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/kernel.h>

    23

#include <linux/module.h>

    24

#include <linux/netdevice.h>

    25

    26

#ifdef CONFIG_PCI

    27

#include <asm/dma.h>

    28

#else

    29

#define free_dma(X)

    30

#define request_dma(X, Y) ((int)(-EINVAL))

    31

#endif

    32

    33

#include "module.h"

    34

    35

/**

    36

 * EtherCAT frame to enable forwarding on EtherCAT Terminals

    37

 */

    38

static const u8 frameForwardEthernetFrames[] = {

    39

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

    40

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

    41

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

    42

	0x08,

    43

	0x00,

    44

	0x00, 0x00,

    45

	0x00, 0x01,

    46

	0x02, 0x00,

    47

	0x00, 0x00,

    48

	0x00, 0x00,

    49

	0x00, 0x00

    50

};

    51

    52

#define FIFO_LENGTH 64

    53

#define POLL_TIME ktime_set(0, 50 * NSEC_PER_USEC)

    54

    55

struct ccat_dma_frame_hdr {

    56

	__le32 reserved1;

    57

	__le32 rx_flags;

    58

#define CCAT_FRAME_RECEIVED 0x1

    59

	__le16 length;

    60

	__le16 reserved3;

    61

	__le32 tx_flags;

    62

#define CCAT_FRAME_SENT 0x1

    63

	__le64 timestamp;

    64

};

    65

    66

struct ccat_eim_frame_hdr {

    67

	__le16 length;

    68

	__le16 reserved3;

    69

	__le32 tx_flags;

    70

	__le64 timestamp;

    71

};

    72

    73

struct ccat_eth_frame {

    74

	u8 placeholder[0x800];

    75

};

    76

    77

struct ccat_dma_frame {

    78

	struct ccat_dma_frame_hdr hdr;

    79

	u8 data[sizeof(struct ccat_eth_frame) -

    80

		sizeof(struct ccat_dma_frame_hdr)];

    81

};

    82

    83

struct ccat_eim_frame {

    84

	struct ccat_eim_frame_hdr hdr;

    85

	u8 data[sizeof(struct ccat_eth_frame) -

    86

		sizeof(struct ccat_eim_frame_hdr)];

    87

};

    88

    89

#define MAX_PAYLOAD_SIZE \

    90

	(sizeof(struct ccat_eth_frame) - max(sizeof(struct ccat_dma_frame_hdr), sizeof(struct ccat_eim_frame_hdr)))

    91

    92

/**

    93

 * struct ccat_eth_register - CCAT register addresses in the PCI BAR

    94

 * @mii: address of the CCAT management interface register

    95

 * @tx_fifo: address of the CCAT TX DMA fifo register

    96

 * @rx_fifo: address of the CCAT RX DMA fifo register

    97

 * @mac: address of the CCAT media access control register

    98

 * @rx_mem: address of the CCAT register holding the RX DMA address

    99

 * @tx_mem: address of the CCAT register holding the TX DMA address

   100

 * @misc: address of a CCAT register holding miscellaneous information

   101

 */

   102

struct ccat_eth_register {

   103

	void __iomem *mii;

   104

	void __iomem *tx_fifo;

   105

	void __iomem *rx_fifo;

   106

	void __iomem *mac;

   107

	void __iomem *rx_mem;

   108

	void __iomem *tx_mem;

   109

	void __iomem *misc;

   110

};

   111

   112

/**

   113

 * struct ccat_dma - CCAT DMA channel configuration

   114

 * @phys: device-viewed address(physical) of the associated DMA memory

   115

 * @start: CPU-viewed address(virtual) of the associated DMA memory

   116

 * @size: number of bytes in the associated DMA memory

   117

 * @channel: CCAT DMA channel number

   118

 * @dev: valid struct device pointer

   119

 */

   120

struct ccat_dma {

   121

	struct ccat_dma_frame *next;

   122

	void *start;

   123

	size_t size;

   124

	dma_addr_t phys;

   125

	size_t channel;

   126

	struct device *dev;

   127

};

   128

   129

struct ccat_eim {

   130

	struct ccat_eim_frame __iomem *next;

   131

	void __iomem *start;

   132

	size_t size;

   133

};

   134

   135

struct ccat_mem {

   136

	struct ccat_eth_frame *next;

   137

	void *start;

   138

};

   139

   140

/**

   141

 * struct ccat_eth_fifo - CCAT RX or TX DMA fifo

   142

 * @add: callback used to add a frame to this fifo

   143

 * @reg: PCI register address of this DMA fifo

   144

 * @dma: information about the associated DMA memory

   145

 */

   146

struct ccat_eth_fifo {

   147

	void (*add) (struct ccat_eth_fifo *);

   148

	void (*copy_to_skb) (struct ccat_eth_fifo *, struct sk_buff *, size_t);

   149

	void (*queue_skb) (struct ccat_eth_fifo * const, struct sk_buff *);

   150

	void __iomem *reg;

   151

	const struct ccat_eth_frame *end;

   152

	union {

   153

		struct ccat_mem mem;

   154

		struct ccat_dma dma;

   155

		struct ccat_eim eim;

   156

	};

   157

};

   158

   159

/**

   160

 * same as: typedef struct _CCatInfoBlockOffs from CCatDefinitions.h

   161

 */

   162

struct ccat_mac_infoblock {

   163

	u32 reserved;

   164

	u32 mii;

   165

	u32 tx_fifo;

   166

	u32 mac;

   167

	u32 rx_mem;

   168

	u32 tx_mem;

   169

	u32 misc;

   170

};

   171

   172

/**

   173

 * struct ccat_eth_priv - CCAT Ethernet/EtherCAT Master function (netdev)

   174

 * @func: pointer to the parent struct ccat_function

   175

 * @netdev: the net_device structure used by the kernel networking stack

   176

 * @info: holds a copy of the CCAT Ethernet/EtherCAT Master function information block (read from PCI config space)

   177

 * @reg: register addresses in PCI config space of the Ethernet/EtherCAT Master function

   178

 * @rx_fifo: DMA fifo used for RX DMA descriptors

   179

 * @tx_fifo: DMA fifo used for TX DMA descriptors

   180

 * @poll_timer: interval timer used to poll CCAT for events like link changed, rx done, tx done

   181

 * @rx_bytes: number of bytes received -> reported with ndo_get_stats64()

   182

 * @rx_dropped: number of received frames, which were dropped -> reported with ndo_get_stats64()

   183

 * @tx_bytes: number of bytes send -> reported with ndo_get_stats64()

   184

 * @tx_dropped: number of frames requested to send, which were dropped -> reported with ndo_get_stats64()

   185

 */

   186

struct ccat_eth_priv {

   187

	void (*free) (struct ccat_eth_priv *);

   188

	 bool(*tx_ready) (const struct ccat_eth_priv *);

   189

	 size_t(*rx_ready) (struct ccat_eth_fifo *);

   190

	struct ccat_function *func;

   191

	struct net_device *netdev;

   192

	struct ccat_eth_register reg;

   193

	struct ccat_eth_fifo rx_fifo;

   194

	struct ccat_eth_fifo tx_fifo;

   195

	struct hrtimer poll_timer;

   196

	atomic64_t rx_bytes;

   197

	atomic64_t rx_dropped;

   198

	atomic64_t tx_bytes;

   199

	atomic64_t tx_dropped;

   200

	ec_device_t *ecdev;

   201

	void (*carrier_off) (struct net_device * netdev);

   202

	 bool(*carrier_ok) (const struct net_device * netdev);

   203

	void (*carrier_on) (struct net_device * netdev);

   204

	void (*kfree_skb_any) (struct sk_buff * skb);

   205

	void (*receive) (struct ccat_eth_priv *, size_t);

   206

	void (*start_queue) (struct net_device * netdev);

   207

	void (*stop_queue) (struct net_device * netdev);

   208

	void (*unregister) (struct net_device * netdev);

   209

};

   210

   211

struct ccat_mac_register {

   212

	/** MAC error register     @+0x0 */

   213

	u8 frame_len_err;

   214

	u8 rx_err;

   215

	u8 crc_err;

   216

	u8 link_lost_err;

   217

	u32 reserved1;

   218

	/** Buffer overflow errors @+0x8 */

   219

	u8 rx_mem_full;

   220

	u8 reserved2[7];

   221

	/** MAC frame counter      @+0x10 */

   222

	u32 tx_frames;

   223

	u32 rx_frames;

   224

	u64 reserved3;

   225

	/** MAC fifo level         @+0x20 */

   226

	u8 tx_fifo_level:7;

   227

	u8 reserved4:1;

   228

	u8 reserved5[7];

   229

	/** TX memory full error   @+0x28 */

   230

	u8 tx_mem_full;

   231

	u8 reserved6[7];

   232

	u64 reserved8[9];

   233

	/** Connection             @+0x78 */

   234

	u8 mii_connected;

   235

};

   236

   237

static void ccat_dma_free(struct ccat_dma *const dma)

   238

{

   239

	const struct ccat_dma tmp = *dma;

   240

   241

	free_dma(dma->channel);

   242

	memset(dma, 0, sizeof(*dma));

   243

	dma_free_coherent(tmp.dev, tmp.size, tmp.start, tmp.phys);

   244

}

   245

   246

/**

   247

 * ccat_dma_init() - Initialize CCAT and host memory for DMA transfer

   248

 * @dma object for management data which will be initialized

   249

 * @channel number of the DMA channel

   250

 * @ioaddr of the pci bar2 configspace used to calculate the address of the pci dma configuration

   251

 * @dev which should be configured for DMA

   252

 */

   253

static int ccat_dma_init(struct ccat_dma *const dma, size_t channel,

   254

			 void __iomem * const ioaddr, struct device *const dev)

   255

{

   256

	void *frame;

   257

	u64 addr;

   258

	u32 translateAddr;

   259

	u32 memTranslate;

   260

	u32 memSize;

   261

	u32 data = 0xffffffff;

   262

	u32 offset = (sizeof(u64) * channel) + 0x1000;

   263

   264

	dma->channel = channel;

   265

	dma->dev = dev;

   266

   267

	/* calculate size and alignments */

   268

	iowrite32(data, ioaddr + offset);

   269

	wmb();

   270

	data = ioread32(ioaddr + offset);

   271

	memTranslate = data & 0xfffffffc;

   272

	memSize = (~memTranslate) + 1;

   273

	dma->size = 2 * memSize - PAGE_SIZE;

   274

	dma->start =

   275

	    dma_zalloc_coherent(dev, dma->size, &dma->phys, GFP_KERNEL);

   276

	if (!dma->start || !dma->phys) {

   277

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

   278

		return -ENOMEM;

   279

	}

   280

   281

	if (request_dma(channel, KBUILD_MODNAME)) {

   282

		pr_info("request dma channel %llu failed\n", (u64) channel);

   283

		ccat_dma_free(dma);

   284

		return -EINVAL;

   285

	}

   286

   287

	translateAddr = (dma->phys + memSize - PAGE_SIZE) & memTranslate;

   288

	addr = translateAddr;

   289

	memcpy_toio(ioaddr + offset, &addr, sizeof(addr));

   290

	frame = dma->start + translateAddr - dma->phys;

   291

	pr_debug

   292

	    ("DMA%llu mem initialized\n start:         0x%p\n phys:         0x%llx\n translated:   0x%llx\n pci addr:     0x%08x%x\n memTranslate: 0x%x\n size:         %llu bytes.\n",

   293

	     (u64) channel, dma->start, (u64) (dma->phys), addr,

   294

	     ioread32(ioaddr + offset + 4), ioread32(ioaddr + offset),

   295

	     memTranslate, (u64) dma->size);

   296

	return 0;

   297

}

   298

   299

static void ecdev_kfree_skb_any(struct sk_buff *skb)

   300

{

   301

	/* never release a skb in EtherCAT mode */

   302

}

   303

   304

static bool ecdev_carrier_ok(const struct net_device *const netdev)

   305

{

   306

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   307

	return ecdev_get_link(priv->ecdev);

   308

}

   309

   310

static void ecdev_carrier_on(struct net_device *const netdev)

   311

{

   312

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   313

	ecdev_set_link(priv->ecdev, 1);

   314

}

   315

   316

static void ecdev_carrier_off(struct net_device *const netdev)

   317

{

   318

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   319

	ecdev_set_link(priv->ecdev, 0);

   320

}

   321

   322

static void ecdev_nop(struct net_device *const netdev)

   323

{

   324

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

   325

}

   326

   327

static void ecdev_receive_dma(struct ccat_eth_priv *const priv, size_t len)

   328

{

   329

	ecdev_receive(priv->ecdev, priv->rx_fifo.dma.next->data, len);

   330

}

   331

   332

static void ecdev_receive_eim(struct ccat_eth_priv *const priv, size_t len)

   333

{

   334

	ecdev_receive(priv->ecdev, priv->rx_fifo.eim.next->data, len);

   335

}

   336

   337

static void unregister_ecdev(struct net_device *const netdev)

   338

{

   339

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   340

	ecdev_close(priv->ecdev);

   341

	ecdev_withdraw(priv->ecdev);

   342

}

   343

   344

static inline bool fifo_eim_tx_ready(const struct ccat_eth_priv *const priv)

   345

{

   346

	static const size_t TX_FIFO_LEVEL_OFFSET = 0x20;

   347

	static const u8 TX_FIFO_LEVEL_MASK = 0x3F;

   348

	void __iomem *addr = priv->reg.mac + TX_FIFO_LEVEL_OFFSET;

   349

   350

	return !(ioread8(addr) & TX_FIFO_LEVEL_MASK);

   351

}

   352

   353

static inline size_t fifo_eim_rx_ready(struct ccat_eth_fifo *const fifo)

   354

{

   355

	static const size_t OVERHEAD = sizeof(struct ccat_eim_frame_hdr);

   356

	const size_t len = ioread16(&fifo->eim.next->hdr.length);

   357

   358

	return (len < OVERHEAD) ? 0 : len - OVERHEAD;

   359

}

   360

   361

static void ccat_eth_fifo_inc(struct ccat_eth_fifo *fifo)

   362

{

   363

	if (++fifo->mem.next > fifo->end)

   364

		fifo->mem.next = fifo->mem.start;

   365

}

   366

   367

static void fifo_eim_rx_add(struct ccat_eth_fifo *const fifo)

   368

{

   369

	struct ccat_eim_frame __iomem *frame = fifo->eim.next;

   370

	iowrite16(0, frame);

   371

	wmb();

   372

}

   373

   374

static void fifo_eim_tx_add(struct ccat_eth_fifo *const fifo)

   375

{

   376

}

   377

   378

#define memcpy_from_ccat(DEST, SRC, LEN) memcpy(DEST,(__force void*)(SRC), LEN)

   379

#define memcpy_to_ccat(DEST, SRC, LEN) memcpy((__force void*)(DEST),SRC, LEN)

   380

static void fifo_eim_copy_to_linear_skb(struct ccat_eth_fifo *const fifo,

   381

					struct sk_buff *skb, const size_t len)

   382

{

   383

	memcpy_from_ccat(skb->data, fifo->eim.next->data, len);

   384

}

   385

   386

static void fifo_eim_queue_skb(struct ccat_eth_fifo *const fifo,

   387

			       struct sk_buff *skb)

   388

{

   389

	struct ccat_eim_frame __iomem *frame = fifo->eim.next;

   390

	const u32 addr_and_length =

   391

	    (void __iomem *)frame - (void __iomem *)fifo->eim.start;

   392

   393

	const __le16 length = cpu_to_le16(skb->len);

   394

	memcpy_to_ccat(&frame->hdr.length, &length, sizeof(length));

   395

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

   396

	iowrite32(addr_and_length, fifo->reg);

   397

}

   398

   399

static void ccat_eth_priv_free_eim(struct ccat_eth_priv *priv)

   400

{

   401

	/* reset hw fifo's */

   402

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

   403

	wmb();

   404

}

   405

   406

static void ccat_eth_fifo_reset(struct ccat_eth_fifo *const fifo)

   407

{

   408

	/* reset hw fifo */

   409

	if (fifo->reg) {

   410

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

   411

		wmb();

   412

	}

   413

   414

	if (fifo->add) {

   415

		fifo->mem.next = fifo->mem.start;

   416

		do {

   417

			fifo->add(fifo);

   418

			ccat_eth_fifo_inc(fifo);

   419

		} while (fifo->mem.next != fifo->mem.start);

   420

	}

   421

}

   422

   423

static inline bool fifo_dma_tx_ready(const struct ccat_eth_priv *const priv)

   424

{

   425

	const struct ccat_dma_frame *frame = priv->tx_fifo.dma.next;

   426

	return le32_to_cpu(frame->hdr.tx_flags) & CCAT_FRAME_SENT;

   427

}

   428

   429

static inline size_t fifo_dma_rx_ready(struct ccat_eth_fifo *const fifo)

   430

{

   431

	static const size_t OVERHEAD =

   432

	    offsetof(struct ccat_dma_frame_hdr, rx_flags);

   433

	const struct ccat_dma_frame *const frame = fifo->dma.next;

   434

   435

	if (le32_to_cpu(frame->hdr.rx_flags) & CCAT_FRAME_RECEIVED) {

   436

		const size_t len = le16_to_cpu(frame->hdr.length);

   437

		return (len < OVERHEAD) ? 0 : len - OVERHEAD;

   438

	}

   439

	return 0;

   440

}

   441

   442

static void ccat_eth_rx_fifo_dma_add(struct ccat_eth_fifo *const fifo)

   443

{

   444

	struct ccat_dma_frame *const frame = fifo->dma.next;

   445

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

   446

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

   447

   448

	frame->hdr.rx_flags = cpu_to_le32(0);

   449

	iowrite32(addr_and_length, fifo->reg);

   450

}

   451

   452

static void ccat_eth_tx_fifo_dma_add_free(struct ccat_eth_fifo *const fifo)

   453

{

   454

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

   455

	fifo->dma.next->hdr.tx_flags = cpu_to_le32(CCAT_FRAME_SENT);

   456

}

   457

   458

static void fifo_dma_copy_to_linear_skb(struct ccat_eth_fifo *const fifo,

   459

					struct sk_buff *skb, const size_t len)

   460

{

   461

	skb_copy_to_linear_data(skb, fifo->dma.next->data, len);

   462

}

   463

   464

static void fifo_dma_queue_skb(struct ccat_eth_fifo *const fifo,

   465

			       struct sk_buff *skb)

   466

{

   467

	struct ccat_dma_frame *frame = fifo->dma.next;

   468

	u32 addr_and_length;

   469

   470

	frame->hdr.tx_flags = cpu_to_le32(0);

   471

	frame->hdr.length = cpu_to_le16(skb->len);

   472

   473

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

   474

   475

	/* Queue frame into CCAT TX-FIFO, CCAT ignores the first 8 bytes of the tx descriptor */

   476

	addr_and_length = offsetof(struct ccat_dma_frame_hdr, length);

   477

	addr_and_length += ((void *)frame - fifo->dma.start);

   478

	addr_and_length +=

   479

	    ((skb->len + sizeof(struct ccat_dma_frame_hdr)) / 8) << 24;

   480

	iowrite32(addr_and_length, fifo->reg);

   481

}

   482

   483

static void ccat_eth_priv_free_dma(struct ccat_eth_priv *priv)

   484

{

   485

	/* reset hw fifo's */

   486

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

   487

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

   488

	wmb();

   489

   490

	/* release dma */

   491

	ccat_dma_free(&priv->rx_fifo.dma);

   492

	ccat_dma_free(&priv->tx_fifo.dma);

   493

}

   494

   495

/**