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

    23

#include <linux/netdevice.h>

    24

#include <linux/platform_device.h>

    25

#include <linux/version.h>

    26

#include "module.h"

    27

    28

MODULE_DESCRIPTION(DRV_DESCRIPTION);

    29

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

    30

MODULE_LICENSE("GPL");

    31

MODULE_VERSION(DRV_VERSION);

    32

    33

#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,12,27))

    34

/*

    35

 * Set both the DMA mask and the coherent DMA mask to the same thing.

    36

 * Note that we don't check the return value from dma_set_coherent_mask()

    37

 * as the DMA API guarantees that the coherent DMA mask can be set to

    38

 * the same or smaller than the streaming DMA mask.

    39

 */

    40

static inline int dma_set_mask_and_coherent(struct device *dev, u64 mask)

    41

{

    42

	int rc = dma_set_mask(dev, mask);

    43

	if (rc == 0)

    44

		dma_set_coherent_mask(dev, mask);

    45

	return rc;

    46

}

    47

#endif

    48

    49

/**

    50

 * configure the drivers capabilities here

    51

 */

    52

static const struct ccat_driver *const drivers[] = {

    53

#ifdef CONFIG_PCI

    54

	&eth_dma_driver,	/* load Ethernet MAC/EtherCAT Master driver with DMA support from netdev.c */

    55

#endif

    56

	&eth_eim_driver,	/* load Ethernet MAC/EtherCAT Master driver without DMA support from */

    57

#ifdef CONFIG_GPIO

    58

	&gpio_driver,		/* load GPIO driver from gpio.c */

    59

#endif

    60

	&sram_driver,		/* load SRAM driver from sram.c */

    61

	&update_driver,		/* load Update driver from update.c */

    62

};

    63

    64

static int __init ccat_class_init(struct ccat_class *base)

    65

{

    66

	if (1 == atomic_inc_return(&base->instances)) {

    67

		if (alloc_chrdev_region

    68

		    (&base->dev, 0, base->count, KBUILD_MODNAME)) {

    69

			pr_warn("alloc_chrdev_region() for '%s' failed\n",

    70

				base->name);

    71

			return -1;

    72

		}

    73

    74

		base->class = class_create(THIS_MODULE, base->name);

    75

		if (!base->class) {

    76

			pr_warn("Create device class '%s' failed\n",

    77

				base->name);

    78

			unregister_chrdev_region(base->dev, base->count);

    79

			return -1;

    80

		}

    81

	}

    82

	return 0;

    83

}

    84

    85

static void ccat_class_exit(struct ccat_class *base)

    86

{

    87

	if (!atomic_dec_return(&base->instances)) {

    88

		class_destroy(base->class);

    89

		unregister_chrdev_region(base->dev, base->count);

    90

	}

    91

}

    92

    93

static void free_ccat_cdev(struct ccat_cdev *ccdev)

    94

{

    95

	ccat_class_exit(ccdev->class);

    96

	ccdev->dev = 0;

    97

}

    98

    99

static struct ccat_cdev *alloc_ccat_cdev(struct ccat_class *base)

   100

{

   101

	int i = 0;

   102

   103

	ccat_class_init(base);

   104

	for (i = 0; i < base->count; ++i) {

   105

		if (base->devices[i].dev == 0) {

   106

			base->devices[i].dev = MKDEV(MAJOR(base->dev), i);

   107

			return &base->devices[i];

   108

		}

   109

	}

   110

	pr_warn("exceeding max. number of '%s' devices (%d)\n",

   111

		base->class->name, base->count);

   112

	atomic_dec_return(&base->instances);

   113

	return NULL;

   114

}

   115

   116

static int ccat_cdev_init(struct cdev *cdev, dev_t dev, struct class *class,

   117

			  struct file_operations *fops)

   118

{

   119

	if (!device_create

   120

	    (class, NULL, dev, NULL, "%s%d", class->name, MINOR(dev))) {

   121

		pr_warn("device_create() failed\n");

   122

		return -1;

   123

	}

   124

   125

	cdev_init(cdev, fops);

   126

	cdev->owner = fops->owner;

   127

	if (cdev_add(cdev, dev, 1)) {

   128

		pr_warn("add update device failed\n");

   129

		device_destroy(class, dev);

   130

		return -1;

   131

	}

   132

   133

	pr_info("registered %s%d.\n", class->name, MINOR(dev));

   134

	return 0;

   135

}

   136

   137

int ccat_cdev_open(struct inode *const i, struct file *const f)

   138

{

   139

	struct ccat_cdev *ccdev =

   140

	    container_of(i->i_cdev, struct ccat_cdev, cdev);

   141

	struct cdev_buffer *buf;

   142

   143

	if (!atomic_dec_and_test(&ccdev->in_use)) {

   144

		atomic_inc(&ccdev->in_use);

   145

		return -EBUSY;

   146

	}

   147

   148

	buf = kzalloc(sizeof(*buf) + ccdev->iosize, GFP_KERNEL);

   149

	if (!buf) {

   150

		atomic_inc(&ccdev->in_use);

   151

		return -ENOMEM;

   152

	}

   153

   154

	buf->ccdev = ccdev;

   155

	f->private_data = buf;

   156

	return 0;

   157

}

   158

   159

int ccat_cdev_probe(struct ccat_function *func, struct ccat_class *cdev_class,

   160

		    size_t iosize)

   161

{

   162

	struct ccat_cdev *const ccdev = alloc_ccat_cdev(cdev_class);

   163

	if (!ccdev) {

   164

		return -ENOMEM;

   165

	}

   166

   167

	ccdev->ioaddr = func->ccat->bar_0 + func->info.addr;

   168

	ccdev->iosize = iosize;

   169

	atomic_set(&ccdev->in_use, 1);

   170

   171

	if (ccat_cdev_init

   172

	    (&ccdev->cdev, ccdev->dev, cdev_class->class, &cdev_class->fops)) {

   173

		pr_warn("ccat_cdev_probe() failed\n");

   174

		free_ccat_cdev(ccdev);

   175

		return -1;

   176

	}

   177

	ccdev->class = cdev_class;

   178

	func->private_data = ccdev;

   179

	return 0;

   180

}

   181

   182

int ccat_cdev_release(struct inode *const i, struct file *const f)

   183

{

   184

	const struct cdev_buffer *const buf = f->private_data;

   185

	struct ccat_cdev *const ccdev = buf->ccdev;

   186

   187

	kfree(f->private_data);

   188

	atomic_inc(&ccdev->in_use);

   189

	return 0;

   190

}

   191

   192

void ccat_cdev_remove(struct ccat_function *func)

   193

{

   194

	struct ccat_cdev *const ccdev = func->private_data;

   195

   196

	cdev_del(&ccdev->cdev);

   197

	device_destroy(ccdev->class->class, ccdev->dev);

   198

	free_ccat_cdev(ccdev);

   199

}

   200

   201

static const struct ccat_driver *ccat_function_connect(struct ccat_function

   202

						       *const func)

   203

{

   204

	int i;

   205

   206

	for (i = 0; i < ARRAY_SIZE(drivers); ++i) {

   207

		if (func->info.type == drivers[i]->type) {

   208

			return drivers[i]->probe(func) ? NULL : drivers[i];

   209

		}

   210

	}

   211

	return NULL;

   212

}

   213

   214

/**

   215

 * Initialize all available CCAT functions.

   216

 *

   217

 * Return: count of failed functions

   218

 */

   219

static int ccat_functions_init(struct ccat_device *const ccatdev)

   220

{

   221

	static const size_t block_size = sizeof(struct ccat_info_block);

   222

	struct ccat_function *next = kzalloc(sizeof(*next), GFP_KERNEL);

   223

	void __iomem *addr = ccatdev->bar_0; /** first block is the CCAT information block entry */

   224

	const u8 num_func = ioread8(addr + 4); /** number of CCAT function blocks is at offset 0x4 */

   225

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

   226

   227

	INIT_LIST_HEAD(&ccatdev->functions);

   228

	for (; addr < end && next; addr += block_size) {

   229

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

   230

		if (CCATINFO_NOTUSED != next->info.type) {

   231

			next->ccat = ccatdev;

   232

			next->drv = ccat_function_connect(next);

   233

			if (next->drv) {

   234

				list_add(&next->list, &ccatdev->functions);

   235

				next = kzalloc(sizeof(*next), GFP_KERNEL);

   236

			}

   237

		}

   238

	}

   239

	kfree(next);

   240

	return list_empty(&ccatdev->functions);

   241

}

   242

   243

/**

   244

 * Destroy all previously initialized CCAT functions

   245

 */

   246

static void ccat_functions_remove(struct ccat_device *const dev)

   247

{

   248

	struct ccat_function *func;

   249

	struct ccat_function *tmp;

   250

	list_for_each_entry_safe(func, tmp, &dev->functions, list) {

   251

		if (func->drv) {

   252

			func->drv->remove(func);

   253

			func->drv = NULL;

   254

		}

   255

		list_del(&func->list);

   256

		kfree(func);

   257

	}

   258

}

   259

   260

#ifdef CONFIG_PCI

   261

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

   262

{

   263

	struct ccat_device *ccatdev;

   264

	u8 rev;

   265

	int status;

   266

   267

	ccatdev = devm_kzalloc(&pdev->dev, sizeof(*ccatdev), GFP_KERNEL);

   268

	if (!ccatdev) {

   269

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

   270

		return -ENOMEM;

   271

	}

   272

	ccatdev->pdev = pdev;

   273

	pci_set_drvdata(pdev, ccatdev);

   274

   275

	status = pci_enable_device_mem(pdev);

   276

	if (status) {

   277

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

   278

		return status;

   279

	}

   280

   281

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

   282

	if (status) {

   283

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

   284

		goto disable_device;

   285

	}

   286

   287

	status = pci_request_regions(pdev, KBUILD_MODNAME);

   288

	if (status) {

   289

		pr_err("allocate mem_regions failed.\n");

   290

		goto disable_device;

   291

	}

   292

   293

	status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));

   294

	if (status) {

   295

		status =

   296

		    dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));

   297

		if (status) {

   298

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

   299

			goto release_regions;

   300

		}

   301

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

   302

	} else {

   303

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

   304

	}

   305

   306

	ccatdev->bar_0 = pci_iomap(pdev, 0, 0);

   307

	if (!ccatdev->bar_0) {

   308

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

   309

		status = -EIO;

   310

		goto release_regions;

   311

	}

   312

   313

	ccatdev->bar_2 = pci_iomap(pdev, 2, 0);

   314

	if (!ccatdev->bar_2) {

   315

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

   316

	}

   317

   318

	pci_set_master(pdev);

   319

	if (ccat_functions_init(ccatdev)) {

   320

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

   321

	}

   322

	return 0;

   323

   324

release_regions:

   325

	pci_release_regions(pdev);

   326

disable_device:

   327

	pci_disable_device(pdev);

   328

	return status;

   329

}

   330

   331

static void ccat_pci_remove(struct pci_dev *pdev)

   332

{

   333

	struct ccat_device *ccatdev = pci_get_drvdata(pdev);

   334

   335

	if (ccatdev) {

   336

		ccat_functions_remove(ccatdev);

   337

		if (ccatdev->bar_2)

   338

			pci_iounmap(pdev, ccatdev->bar_2);

   339

		pci_iounmap(pdev, ccatdev->bar_0);

   340

		pci_release_regions(pdev);

   341

		pci_disable_device(pdev);

   342

	}

   343

}

   344

   345

#define PCI_DEVICE_ID_BECKHOFF_CCAT 0x5000

   346

#define PCI_VENDOR_ID_BECKHOFF 0x15EC

   347

   348

static const struct pci_device_id pci_ids[] = {

   349

	{PCI_DEVICE(PCI_VENDOR_ID_BECKHOFF, PCI_DEVICE_ID_BECKHOFF_CCAT)},

   350

	{0,},

   351

};

   352

   353

/* prevent auto-loading. */

   354

/* MODULE_DEVICE_TABLE(pci, pci_ids); */

   355

   356

static struct pci_driver ccat_pci_driver = {

   357

	.name = KBUILD_MODNAME,

   358

	.id_table = pci_ids,

   359

	.probe = ccat_pci_probe,

   360

	.remove = ccat_pci_remove,

   361

};

   362

   363

module_pci_driver(ccat_pci_driver);

   364

   365

#else /* #ifdef CONFIG_PCI */

   366

   367

static int ccat_eim_probe(struct platform_device *pdev)

   368

{

   369

	struct ccat_device *ccatdev;

   370

   371

	ccatdev = devm_kzalloc(&pdev->dev, sizeof(*ccatdev), GFP_KERNEL);

   372

	if (!ccatdev) {

   373

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

   374

		return -ENOMEM;

   375

	}

   376

	ccatdev->pdev = pdev;

   377

	platform_set_drvdata(pdev, ccatdev);

   378

   379

	if (!request_mem_region(0xf0000000, 0x02000000, pdev->name)) {

   380

		pr_warn("request mem region failed.\n");

   381

		return -EIO;

   382

	}

   383

   384

	if (!(ccatdev->bar_0 = ioremap(0xf0000000, 0x02000000))) {

   385

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

   386

		return -EIO;

   387

	}

   388

   389

	ccatdev->bar_2 = NULL;

   390

   391

	if (ccat_functions_init(ccatdev)) {

   392

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

   393

	}

   394

	return 0;

   395

}

   396

   397

static int ccat_eim_remove(struct platform_device *pdev)

   398

{

   399

	struct ccat_device *ccatdev = platform_get_drvdata(pdev);

   400

   401

	if (ccatdev) {

   402

		ccat_functions_remove(ccatdev);

   403

		iounmap(ccatdev->bar_0);

   404

		release_mem_region(0xf0000000, 0x02000000);

   405

	}

   406

	return 0;

   407

}

   408

   409

static const struct of_device_id bhf_eim_ccat_ids[] = {

   410

	{.compatible = "bhf,emi-ccat",},

   411

	{}

   412

};

   413

   414

/* prevent auto-loading. */

   415

/* MODULE_DEVICE_TABLE(of, bhf_eim_ccat_ids); */

   416

   417

static struct platform_driver ccat_eim_driver = {

   418

	.driver = {

   419

		   .name = KBUILD_MODNAME,

   420

		   .of_match_table = bhf_eim_ccat_ids,

   421

		   },

   422

	.probe = ccat_eim_probe,

   423

	.remove = ccat_eim_remove,

   424

};

   425

   426

module_platform_driver(ccat_eim_driver);

   427

#endif /* #ifdef CONFIG_PCI */