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

    22

#include <linux/kernel.h>

    23

#include <linux/module.h>

    24

#include <linux/sched.h>

    25

#include <linux/uaccess.h>

    26

#include "module.h"

    27

#include "update.h"

    28

    29

#define CCAT_DATA_IN_4 0x038

    30

#define CCAT_DATA_IN_N 0x7F0

    31

#define CCAT_DATA_OUT_4 0x030

    32

#define CCAT_DATA_BLOCK_SIZE (size_t)((CCAT_DATA_IN_N - CCAT_DATA_IN_4)/8)

    33

#define CCAT_WRITE_BLOCK_SIZE 128

    34

#define CCAT_FLASH_SIZE (size_t)0xE0000

    35

    36

/**     FUNCTION_NAME            CMD,  CLOCKS          */

    37

#define CCAT_BULK_ERASE          0xE3, 8

    38

#define CCAT_GET_PROM_ID         0xD5, 40

    39

#define CCAT_READ_FLASH          0xC0, 32

    40

#define CCAT_READ_STATUS         0xA0, 16

    41

#define CCAT_WRITE_ENABLE        0x60, 8

    42

#define CCAT_WRITE_FLASH         0x40, 32

    43

    44

/* from http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith32Bits */

    45

#define SWAP_BITS(B) \

    46

	((((B) * 0x0802LU & 0x22110LU) | ((B) * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16)

    47

    48

/**

    49

 * struct update_buffer - keep track of a CCAT FPGA update

    50

 * @update: pointer to a valid ccat_update object

    51

 * @data: buffer used for write operations

    52

 * @size: number of bytes written to the data buffer, if 0 on ccat_update_release() no data will be written to FPGA

    53

 */

    54

struct update_buffer {

    55

	struct ccat_update *update;

    56

	char data[CCAT_FLASH_SIZE];

    57

	size_t size;

    58

};

    59

    60

/**

    61

 * wait_until_busy_reset() - wait until the busy flag was reset

    62

 * @ioaddr: address of the CCAT Update function in PCI config space

    63

 */

    64

static inline void wait_until_busy_reset(void __iomem * const ioaddr)

    65

{

    66

	wmb();

    67

	while (ioread8(ioaddr + 1)) {

    68

		schedule();

    69

	}

    70

}

    71

   281

static int ccat_update_open(struct inode *const i, struct file *const f)

   282

{

   283

	struct ccat_update *update =

   284

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

   285

	struct update_buffer *buf;

   286

   287

	kref_get(&update->refcount);

   288

	if (atomic_read(&update->refcount.refcount) > 2) {

   289

		kref_put(&update->refcount, ccat_update_destroy);

   290

		return -EBUSY;

   291

	}

   292

   293

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

   294

	if (!buf) {

   295

		kref_put(&update->refcount, ccat_update_destroy);

   296

		return -ENOMEM;

   297

	}

   298

   299

	buf->update = update;

   300

	f->private_data = buf;

   301

	return 0;

   302

}

   303

   304

static int ccat_update_release(struct inode *const i, struct file *const f)

   305

{

   306

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

   307

	struct ccat_update *const update = buf->update;

   308

   309

	if (buf->size > 0) {

   310

		ccat_update_cmd(update->ioaddr, CCAT_WRITE_ENABLE);

   311

		ccat_update_cmd(update->ioaddr, CCAT_BULK_ERASE);

   312

		ccat_wait_status_cleared(update->ioaddr);

   313

		ccat_write_flash(buf);

   314

	}

   315

	kfree(f->private_data);

   316

	kref_put(&update->refcount, ccat_update_destroy);

   317

	return 0;

   318

}

   319

   320

/**

   321

 * ccat_update_read() - Read CCAT configuration data from flash

   322

 * @f: file handle previously initialized with ccat_update_open()

   323

 * @buf: buffer in user space provided for our data

   324

 * @len: length of the user space buffer

   325

 * @off: current offset of our file operation

   326

 *

   327

 * Copies data from the CCAT FPGA's configuration flash to user space.

   328

 * Note that the size of the FPGA's firmware is not known exactly so it

   329

 * is very possible that the overall buffer ends with a lot of 0xff.

   330

 *

   331

 * Return: the number of bytes written, or 0 if EOF reached

   332

 */

   333

static ssize_t ccat_update_read(struct file *const f, char __user * buf,

   334

				size_t len, loff_t * off)

   335

{

   336

	struct update_buffer *update = f->private_data;

   337

   338

	if (!buf || !off) {

   339

		return -EINVAL;

   340

	}

   341

	if (*off >= CCAT_FLASH_SIZE) {

   342

		return 0;

   343

	}

   344

	if (*off + len >= CCAT_FLASH_SIZE) {

   345

		len = CCAT_FLASH_SIZE - *off;

   346

	}

   347

	return ccat_read_flash(update->update->ioaddr, buf, len, off);

   348

}

   349

   350

/**

   351

 * ccat_update_write() - Write data to the CCAT FPGA's configuration flash

   352

 * @f: file handle previously initialized with ccat_update_open()

   353

 * @buf: buffer in user space providing the new configuration data (from *.rbf)

   354

 * @len: length of the user space buffer

   355

 * @off: current offset in the configuration data

   356

 *

   357

 * Copies data from user space (possibly a *.rbf) to the CCAT FPGA's

   358

 * configuration flash to user space.

   359

 *

   360

 * Return: the number of bytes written, or 0 if flash end is reached

   361

 */

   362

   363

static ssize_t ccat_update_write(struct file *const f, const char __user * buf,

   364

				 size_t len, loff_t * off)

   365

{

   366

	struct update_buffer *const update = f->private_data;

   367

   368

	if (*off + len > sizeof(update->data))

   369

		return 0;

   370

   371

	if (copy_from_user(update->data + *off, buf, len)) {

   372

		return -EFAULT;

   373

	}

   374

   375

	*off += len;

   376

	update->size = *off;

   377

	return len;

   378

}

   379

   380

static struct file_operations update_ops = {

   381

	.owner = THIS_MODULE,

   382

	.open = ccat_update_open,

   383

	.release = ccat_update_release,

   384

	.read = ccat_update_read,

   385

	.write = ccat_update_write,

   386

};

   387

   388

/**

   389

 * ccat_get_prom_id() - Read CCAT PROM ID

   390

 * @ioaddr: address of the CCAT Update function in PCI config space

   391

 *

   392

 * Return: the CCAT FPGA's PROM identifier

   393

 */

   394

u8 ccat_get_prom_id(void __iomem * const ioaddr)

   395

{

   396

	ccat_update_cmd(ioaddr, CCAT_GET_PROM_ID);

   397

	return ioread8(ioaddr + 0x38);

   398

}

   399

   400

/**

   401

 * ccat_update_init() - Initialize the CCAT Update function

   402

 */

   403

struct ccat_update *ccat_update_init(const struct ccat_device *const ccatdev,

   404

				     void __iomem * const addr)

   405

{

   406

	struct ccat_update *const update = kzalloc(sizeof(*update), GFP_KERNEL);

   407

   408

	if (!update) {

   409

		return NULL;

   410

	}

   411

	kref_init(&update->refcount);

   412

	update->ioaddr = ccatdev->bar[0].ioaddr + ioread32(addr + 0x8);

   413

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

   414

   415

	if (0x00 != update->info.rev) {

   416

		pr_warn("CCAT Update rev. %d not supported\n", update->info.rev);

   417

		goto cleanup;

   418

	}

   419

   420

	if (alloc_chrdev_region(&update->dev, 0, 1, KBUILD_MODNAME)) {

   421

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

   422

		goto cleanup;

   423

	}

   424

   425

	update->class = class_create(THIS_MODULE, "ccat_update");

   426

	if (NULL == update->class) {

   427

		pr_warn("Create device class failed\n");

   428

		goto cleanup;

   429

	}

   430

   431

	if (NULL ==

   432

	    device_create(update->class, NULL, update->dev, NULL,

   433

			  "ccat_update")) {

   434

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

   435

		goto cleanup;

   436

	}

   437

   438

	cdev_init(&update->cdev, &update_ops);

   439

	update->cdev.owner = THIS_MODULE;

   440

	update->cdev.ops = &update_ops;

   441

	if (cdev_add(&update->cdev, update->dev, 1)) {

   442

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

   443

		goto cleanup;

   444

	}

   445

	return update;

   446

cleanup:

   447

	kref_put(&update->refcount, ccat_update_destroy);

   448

	return NULL;

   449

}

   450

   451

/**

   452

 * ccat_update_remove() - Prepare the CCAT Update function for removal

   453

 */

   454

void ccat_update_remove(struct ccat_update *update)

   455

{

   456

	kref_put(&update->refcount, ccat_update_destroy);

   457

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

   458

}