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 <asm/dma.h>

    22

#include <linux/etherdevice.h>

    23

#include <linux/module.h>

    24

#include <linux/netdevice.h>

    25

#include "module.h"

    26

#include "netdev.h"

    27

#include "update.h"

    28

    29

MODULE_DESCRIPTION(DRV_DESCRIPTION);

    30

MODULE_AUTHOR("Patrick Bruenn <p.bruenn@beckhoff.com>");

    31

MODULE_LICENSE("GPL");

    32

MODULE_VERSION(DRV_VERSION);

    33

    34

static void ccat_bar_free(struct ccat_bar *bar)

    35

{

    36

	if (bar->ioaddr) {

    37

		const struct ccat_bar tmp = *bar;

    38

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

    39

		iounmap(tmp.ioaddr);

    40

		release_mem_region(tmp.start, tmp.len);

    41

	} else {

    42

		pr_warn("%s(): %p was already done.\n", __FUNCTION__, bar);

    43

	}

    44

}

    45

    46

/**

    47

 * ccat_bar_init() - Initialize a CCAT pci bar

    48

 * @bar object which should be initialized

    49

 * @index 0 and 2 are valid for CCAT, meaning pci bar0 or pci bar2

    50

 * @pdev the pci device as which the CCAT was recognized before

    51

 *

    52

 * Reading PCI config space; request and map memory region.

    53

 */

    54

static int ccat_bar_init(struct ccat_bar *bar, size_t index,

    55

			 struct pci_dev *pdev)

    56

{

    57

	struct resource *res;

    58

	bar->start = pci_resource_start(pdev, index);

    59

	bar->end = pci_resource_end(pdev, index);

    60

	bar->len = pci_resource_len(pdev, index);

    61

	bar->flags = pci_resource_flags(pdev, index);

    62

	if (!(IORESOURCE_MEM & bar->flags)) {

    63

		pr_info("bar%llu is no mem_region -> abort.\n",

    64

			(uint64_t) index);

    65

		return -EIO;

    66

	}

    67

    68

	res = request_mem_region(bar->start, bar->len, DRV_NAME);

    69

	if (!res) {

    70

		pr_info("allocate mem_region failed.\n");

    71

		return -EIO;

    72

	}

    73

	pr_debug("bar%llu at [%lx,%lx] len=%lu res: %p.\n", (uint64_t) index,

    74

		 bar->start, bar->end, bar->len, res);

    75

    76

	bar->ioaddr = ioremap(bar->start, bar->len);

    77

	if (!bar->ioaddr) {

    78

		pr_info("bar%llu ioremap failed.\n", (uint64_t) index);

    79

		release_mem_region(bar->start, bar->len);

    80

		return -EIO;

    81

	}

    82

	pr_debug("bar%llu I/O mem mapped to %p.\n", (uint64_t) index,

    83

		 bar->ioaddr);

    84

	return 0;

    85

}

    86

    87

void ccat_dma_free(struct ccat_dma *const dma)

    88

{

    89

	const struct ccat_dma tmp = *dma;

    90

	free_dma(dma->channel);

    91

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

    92

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

    93

}

    94

    95

/**

    96

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

    97

 * @dma object for management data which will be initialized

    98

 * @channel number of the DMA channel

    99

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

   100

 * @dev which should be configured for DMA

   101

 */

   102

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

   103

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

   104

{

   105

	void *frame;

   106

	uint64_t addr;

   107

	uint32_t translateAddr;

   108

	uint32_t memTranslate;

   109

	uint32_t memSize;

   110

	uint32_t data = 0xffffffff;

   111

	uint32_t offset = (sizeof(uint64_t) * channel) + 0x1000;

   112

   113

	dma->channel = channel;

   114

	dma->dev = dev;

   115

   116

	/* calculate size and alignments */

   117

	iowrite32(data, ioaddr + offset);

   118

	wmb();

   119

	data = ioread32(ioaddr + offset);

   120

	memTranslate = data & 0xfffffffc;

   121

	memSize = (~memTranslate) + 1;

   122

	dma->size = 2 * memSize - PAGE_SIZE;

   123

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

   124

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

   125

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

   126

		return -1;

   127

	}

   128

   129

	if (request_dma(channel, DRV_NAME)) {

   130

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

   131

			(uint64_t) channel);

   132

		ccat_dma_free(dma);

   133

		return -1;

   134

	}

   135

   136

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

   137

	addr = translateAddr;

   138

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

   139

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

   140

	pr_debug

   141

	    ("DMA%llu mem initialized\n virt:         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",

   142

	     (uint64_t) channel, dma->virt, (uint64_t) (dma->phys), addr,

   143

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

   144

	     memTranslate, (uint64_t) dma->size);

   145

	return 0;

   146

}

   147

   148

/**

   149

 * Initialize all available CCAT functions.

   150

 *

   151

 * Return: count of failed functions

   152

 */

   153

static int ccat_functions_init(struct ccat_device *const ccatdev)

   154

{

   155

	/* read CCatInfoBlock.nMaxEntries from ccat */

   156

	const uint8_t num_func = ioread8(ccatdev->bar[0].ioaddr + 4);

   157

	void __iomem *addr = ccatdev->bar[0].ioaddr;

   158

	const void __iomem *end = addr + (sizeof(CCatInfoBlock) * num_func);

   159

	int status = 0;		//count init function failures

   160

   161

	while (addr < end) {

   162

		const uint8_t type = ioread16(addr);

   163

		switch (type) {

   164

		case CCATINFO_NOTUSED:

   165

			break;

   166

		case CCATINFO_EPCS_PROM:

   167

			pr_info("Found: CCAT update(EPCS_PROM) -> init()\n");

   168

			ccatdev->update = ccat_update_init(ccatdev, addr);

   169

			status += (NULL == ccatdev->update);

   170

			break;

   171

		case CCATINFO_ETHERCAT_MASTER_DMA:

   172

			pr_info("Found: ETHERCAT_MASTER_DMA -> init()\n");

   173

			ccatdev->ethdev = ccat_eth_init(ccatdev, addr);

   174

			status += (NULL == ccatdev->ethdev);

   175

			break;

   176

		default:

   177

			pr_info("Found: 0x%04x not supported\n", type);

   178

			break;

   179

		}

   180

		addr += sizeof(CCatInfoBlock);

   181

	}

   182

	return status;

   183

}

   184

   185

/**

   186

 * Destroy all previously initialized CCAT functions

   187

 */

   188

static void ccat_functions_remove(struct ccat_device *const ccatdev)

   189

{

   190

	if (!ccatdev->ethdev) {

   191

		pr_warn("%s(): 'ethdev' was not initialized.\n", __FUNCTION__);

   192

	} else {

   193

		struct ccat_eth_priv *const ethdev = ccatdev->ethdev;

   194

		ccatdev->ethdev = NULL;

   195

		ccat_eth_remove(ethdev);

   196

	}

   197

	if (!ccatdev->update) {

   198

		pr_warn("%s(): 'update' was not initialized.\n", __FUNCTION__);

   199

	} else {

   200

		struct ccat_update *const update = ccatdev->update;

   201

		ccatdev->update = NULL;

   202

		ccat_update_remove(update);

   203

	}

   204

}

   205

   206

static int ccat_probe(struct pci_dev *pdev, const struct pci_device_id *id)

   207

{

   208

	int status;

   209

	u8 revision;

   210

	struct ccat_device *ccatdev = kmalloc(sizeof(*ccatdev), GFP_KERNEL);

   211

	if (!ccatdev) {

   212

		pr_err("%s() out of memory.\n", __FUNCTION__);

   213

		return -ENOMEM;

   214

	}

   215

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

   216

	ccatdev->pdev = pdev;

   217

	pci_set_drvdata(pdev, ccatdev);

   218

   219

	status = pci_enable_device_mem(pdev);

   220

	if (status) {

   221

		pr_info("enable %s failed: %d\n", pdev->dev.kobj.name, status);

   222

		return status;

   223

	}

   224

   225

	status = pci_read_config_byte(pdev, PCI_REVISION_ID, &revision);

   226

	if (status) {

   227

		pr_warn("read CCAT pci revision failed with %d\n", status);

   228

		return status;

   229

	}

   230

   231

	/* FIXME upgrade to a newer kernel to get support of dma_set_mask_and_coherent()

   232

	 * (!dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(64))) {

   233

	 */

   234

	if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {

   235

		pr_debug("64 bit DMA supported, pci rev: %u\n", revision);

   236

		/*} else if (!dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32))) { */

   237

	} else if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {

   238

		pr_debug("32 bit DMA supported, pci rev: %u\n", revision);

   239

	} else {

   240

		pr_warn("No suitable DMA available, pci rev: %u\n", revision);

   241

	}

   242

   243

	if (ccat_bar_init(&ccatdev->bar[0], 0, pdev)) {

   244

		pr_warn("initialization of bar0 failed.\n");

   245

		return -EIO;

   246

	}

   247

   248

	if (ccat_bar_init(&ccatdev->bar[2], 2, pdev)) {

   249

		pr_warn("initialization of bar2 failed.\n");

   250

		return -EIO;

   251

	}

   252

   253

	pci_set_master(pdev);

   254

	if (ccat_functions_init(ccatdev)) {

   255

		pr_warn("some functions couldn't be initialized\n");

   256

	}

   257

	return 0;

   258

}

   259

   260

static void ccat_remove(struct pci_dev *pdev)

   261

{

   262

	struct ccat_device *ccatdev = pci_get_drvdata(pdev);

   263

	if (ccatdev) {

   264

		ccat_functions_remove(ccatdev);

   265

		ccat_bar_free(&ccatdev->bar[2]);

   266

		ccat_bar_free(&ccatdev->bar[0]);

   267

		pci_disable_device(pdev);

   268

		pci_set_drvdata(pdev, NULL);

   269

		kfree(ccatdev);

   270

	}

   271

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

   272

}

   273

   274

#define PCI_DEVICE_ID_BECKHOFF_CCAT 0x5000

   275

#define PCI_VENDOR_ID_BECKHOFF 0x15EC

   276

   277

static const struct pci_device_id pci_ids[] = {

   278

	{PCI_DEVICE(PCI_VENDOR_ID_BECKHOFF, PCI_DEVICE_ID_BECKHOFF_CCAT)},

   279

	{0,},

   280

};

   281

   282

MODULE_DEVICE_TABLE(pci, pci_ids);

   283

   284

static struct pci_driver pci_driver = {

   285

	.name = DRV_NAME,

   286

	.id_table = pci_ids,

   287

	.probe = ccat_probe,

   288

	.remove = ccat_remove,

   289

};

   290

   291

static void ccat_exit_module(void)

   292

{

   293

	pci_unregister_driver(&pci_driver);

   294

}

   295

   296

static int ccat_init_module(void)

   297

{

   298

	static const size_t offset = offsetof(struct ccat_eth_frame, data);

   299

	BUILD_BUG_ON(sizeof(struct ccat_eth_frame) != sizeof(CCatDmaTxFrame));

   300

	BUILD_BUG_ON(sizeof(struct ccat_eth_frame) != sizeof(CCatRxDesc));

   301

	BUILD_BUG_ON(offset != offsetof(CCatDmaTxFrame, data));

   302

	BUILD_BUG_ON(offset != offsetof(CCatRxDesc, data));

   303

	pr_info("%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);

   304

	return pci_register_driver(&pci_driver);

   305

}

   306

   307

module_exit(ccat_exit_module);

   308

module_init(ccat_init_module);