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)

    56

    57

struct ccat_dma_frame_hdr {

    58

	__le32 reserved1;

    59

	__le32 rx_flags;

    60

#define CCAT_FRAME_RECEIVED 0x1

    61

	__le16 length;

    62

	__le16 reserved3;

    63

	__le32 tx_flags;

    64

#define CCAT_FRAME_SENT 0x1

    65

	__le64 timestamp;

    66

};

    67

    68

struct ccat_eim_frame_hdr {

    69

	__le16 length;

    70

	__le16 reserved3;

    71

	__le32 tx_flags;

    72

	__le64 timestamp;

    73

};

    74

    75

struct ccat_eth_frame {

    76

	u8 placeholder[0x800];

    77

};

    78

    79

struct ccat_dma_frame {

    80

	struct ccat_dma_frame_hdr hdr;

    81

	u8 data[sizeof(struct ccat_eth_frame) -

    82

		sizeof(struct ccat_dma_frame_hdr)];

    83

};

    84

    85

struct ccat_eim_frame {

    86

	struct ccat_eim_frame_hdr hdr;

    87

	u8 data[sizeof(struct ccat_eth_frame) -

    88

		sizeof(struct ccat_eim_frame_hdr)];

    89

};

    90

    91

#define MAX_PAYLOAD_SIZE \

    92

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

    93

    94

/**

    95

 * struct ccat_eth_register - CCAT register addresses in the PCI BAR

    96

 * @mii: address of the CCAT management interface 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 *mac;

   105

	void __iomem *rx_mem;

   106

	void __iomem *tx_mem;

   107

	void __iomem *misc;

   108

};

   109

   110

/**

   113

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

   114

 * @channel: CCAT DMA channel number

   115

 * @dev: valid struct device pointer

   119

	size_t size;

   120

	dma_addr_t phys;

   121

	size_t channel;

   122

	struct device *dev;

   134

};

   135

   136

struct ccat_eim {

   137

	struct ccat_eim_frame __iomem *next;

   138

	void __iomem *start;

   139

};

   140

   141

struct ccat_mem {

   142

	struct ccat_eth_frame *next;

   143

	void *start;

   144

};

   145

   146

/**

   153

 */

   154

struct ccat_eth_fifo {

   157

	void __iomem *reg;

   160

	union {

   161

		struct ccat_mem mem;

   162

		struct ccat_dma dma;

   163

		struct ccat_eim eim;

   164

	};

   165

};

   166

   167

/**

   185

 * same as: typedef struct _CCatInfoBlockOffs from CCatDefinitions.h

   186

 */

   187

struct ccat_mac_infoblock {

   188

	u32 reserved;

   189

	u32 mii;

   190

	u32 tx_fifo;

   191

	u32 mac;

   192

	u32 rx_mem;

   193

	u32 tx_mem;

   194

	u32 misc;

   195

};

   196

   197

/**

   198

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

   199

 * @func: pointer to the parent struct ccat_function

   200

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

   201

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

   204

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

   205

 */

   206

struct ccat_eth_priv {

   207

	struct ccat_function *func;

   208

	struct net_device *netdev;

   209

	struct ccat_eth_register reg;

   210

	struct ccat_eth_fifo rx_fifo;

   211

	struct ccat_eth_fifo tx_fifo;

   212

	struct hrtimer poll_timer;

   214

	ec_device_t *ecdev;

   215

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

   216

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

   217

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

   218

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

   219

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

   220

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

   221

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

   222

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

   223

};

   224

   225

struct ccat_mac_register {

   226

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

   227

	u8 frame_len_err;

   228

	u8 rx_err;

   229

	u8 crc_err;

   230

	u8 link_lost_err;

   231

	u32 reserved1;

   232

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

   233

	u8 rx_mem_full;

   234

	u8 reserved2[7];

   235

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

   236

	u32 tx_frames;

   237

	u32 rx_frames;

   238

	u64 reserved3;

   239

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

   240

	u8 tx_fifo_level:7;

   241

	u8 reserved4:1;

   242

	u8 reserved5[7];

   243

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

   244

	u8 tx_mem_full;

   245

	u8 reserved6[7];

   246

	u64 reserved8[9];

   247

	/** Connection             @+0x78 */

   248

	u8 mii_connected;

   249

};

   250

   266

}

   267

   268

/**

   269

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

   270

 * @dma object for management data which will be initialized

   271

 * @channel number of the DMA channel

   272

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

   273

 * @dev which should be configured for DMA

   274

 */

   285

	if (request_dma(channel, KBUILD_MODNAME)) {

   286

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

   287

		return -EINVAL;

   288

	}

   289

   294

	pr_debug

   299

	return 0;

   300

}

   301

   302

static void ecdev_kfree_skb_any(struct sk_buff *skb)

   303

{

   304

	/* never release a skb in EtherCAT mode */

   305

}

   306

   307

static bool ecdev_carrier_ok(const struct net_device *const netdev)

   308

{

   309

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   310

	return ecdev_get_link(priv->ecdev);

   311

}

   312

   313

static void ecdev_carrier_on(struct net_device *const netdev)

   314

{

   315

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   316

	ecdev_set_link(priv->ecdev, 1);

   317

}

   318

   319

static void ecdev_carrier_off(struct net_device *const netdev)

   320

{

   321

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   322

	ecdev_set_link(priv->ecdev, 0);

   323

}

   324

   325

static void ecdev_nop(struct net_device *const netdev)

   326

{

   327

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

   328

}

   329

   330

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

   331

{

   332

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

   333

}

   334

   335

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

   336

{

   337

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

   338

}

   339

   340

static void unregister_ecdev(struct net_device *const netdev)

   341

{

   342

	struct ccat_eth_priv *const priv = netdev_priv(netdev);

   343

	ecdev_close(priv->ecdev);

   344

	ecdev_withdraw(priv->ecdev);

   345

}

   346

   351

	static const size_t TX_FIFO_LEVEL_OFFSET = 0x20;

   352

	static const u8 TX_FIFO_LEVEL_MASK = 0x3F;

   353

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

   354

   355

	return !(ioread8(addr) & TX_FIFO_LEVEL_MASK);

   356

}

   357

   358

static inline size_t fifo_eim_rx_ready(struct ccat_eth_fifo *const fifo)

   359

{

   360

	static const size_t OVERHEAD = sizeof(struct ccat_eim_frame_hdr);

   361

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

   362

   363

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

   364

}

   365

   366

static void ccat_eth_fifo_inc(struct ccat_eth_fifo *fifo)

   367

{

   368

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

   369

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

   370

}

   371

   372

static void fifo_eim_rx_add(struct ccat_eth_fifo *const fifo)

   373

{

   374

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

   375

	iowrite16(0, frame);

   376

	wmb();

   377

}

   378

   379

static void fifo_eim_tx_add(struct ccat_eth_fifo *const fifo)

   380

{

   381

}

   382

   383

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

   384

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

   385

static void fifo_eim_copy_to_linear_skb(struct ccat_eth_fifo *const fifo,

   386

					struct sk_buff *skb, const size_t len)

   387

{

   388

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

   389

}

   390

   391

static void fifo_eim_queue_skb(struct ccat_eth_fifo *const fifo,

   392

			       struct sk_buff *skb)

   393

{

   394

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

   395

	const u32 addr_and_length =

   396

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

   397

   398

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

   399

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

   400

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

   401

	iowrite32(addr_and_length, fifo->reg);

   402

}

   403

   406

	if (fifo->reg) {

   407

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

   408

		wmb();

   409

	}

   417

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

   418

		do {

   420

			ccat_eth_fifo_inc(fifo);

   421

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

   422

	}

   423

}

   424

   428

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

   429

}

   430

   431

static inline size_t fifo_dma_rx_ready(struct ccat_eth_fifo *const fifo)

   432

{

   433

	static const size_t OVERHEAD =

   434

	    offsetof(struct ccat_dma_frame_hdr, rx_flags);

   435

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

   436

   437

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

   438

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

   439

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

   440

	}

   441

	return 0;

   442

}

   443

   444

static void ccat_eth_rx_fifo_dma_add(struct ccat_eth_fifo *const fifo)

   445

{

   446

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

   447

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

   448

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

   449

   450

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

   451

	iowrite32(addr_and_length, fifo->reg);

   452

}

   453

   454

static void ccat_eth_tx_fifo_dma_add_free(struct ccat_eth_fifo *const fifo)

   455

{

   456

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

   457

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

   458

}

   459

   460

static void fifo_dma_copy_to_linear_skb(struct ccat_eth_fifo *const fifo,

   461

					struct sk_buff *skb, const size_t len)

   462

{

   463

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

   464

}

   465

   466

static void fifo_dma_queue_skb(struct ccat_eth_fifo *const fifo,

   467

			       struct sk_buff *skb)

   468

{

   469

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

   470

	u32 addr_and_length;

   471

   472

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

   473

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

   474

   475

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

   476

   477

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

   478

	addr_and_length = offsetof(struct ccat_dma_frame_hdr, length);

   479

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

   480

	addr_and_length +=

   481

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

   482

	iowrite32(addr_and_length, fifo->reg);

   483

}

   484