/*****************************************************************************
 *
 *  $Id$
 *
 *  Copyright (C) 2009-2010  Moehwald GmbH B. Benner
 *                     2011  IgH Andreas Stewering-Bone
 *                     2012  Florian Pose <fp@igh-essen.com>
 *
 *  This file is part of the IgH EtherCAT master.
 *
 *  The IgH EtherCAT master is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as published
 *  by the Free Software Foundation; version 2 of the License.
 *
 *  The IgH EtherCAT master is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 *  Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with the IgH EtherCAT master. If not, see <http://www.gnu.org/licenses/>.
 *
 *  The license mentioned above concerns the source code only. Using the
 *  EtherCAT technology and brand is only permitted in compliance with the
 *  industrial property and similar rights of Beckhoff Automation GmbH.
 *
 ****************************************************************************/

/** \file
 * RTDM interface.
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/mman.h>

#include <rtdm/driver.h>

#include "master.h"
#include "ioctl.h"
#include "rtdm.h"

/** Set to 1 to enable device operations debugging.
 */
#define DEBUG 0


/****************************************************************************/

int ec_rtdm_open(struct rtdm_fd *, int);
void ec_rtdm_close(struct rtdm_fd *);
int ec_rtdm_rt_ioctl(struct rtdm_fd *,
        unsigned int, void __user *);
int ec_rtdm_ioctl(struct rtdm_fd *,
        unsigned int, void __user *);
int ec_rtdm_mmap(struct rtdm_fd *fd, struct vm_area_struct *vma);

/****************************************************************************/

static struct rtdm_driver ec_rtdm_driver = {
	.profile_info		=	RTDM_PROFILE_INFO(foo,
							  RTDM_CLASS_EXPERIMENTAL,
							  222,
							  1),
	.device_flags		=	RTDM_NAMED_DEVICE,
	.device_count		=	1,
	.context_size		=	sizeof(ec_ioctl_context_t),
	.ops = {
        .open      = ec_rtdm_open,
        .close     = ec_rtdm_close,
        .ioctl_rt  = ec_rtdm_rt_ioctl,
        .ioctl_nrt = ec_rtdm_ioctl,
        .mmap      = ec_rtdm_mmap
	},
};

/** Initialize an RTDM device.
 *
 * \return Zero on success, otherwise a negative error code.
 */
int ec_rtdm_dev_init(
        ec_rtdm_dev_t *rtdm_dev, /**< EtherCAT RTDM device. */
        ec_master_t *master /**< EtherCAT master. */
        )
{
    int ret;
    char* devlabel;

    rtdm_dev->master = master;

    rtdm_dev->dev = kzalloc(sizeof(struct rtdm_device), GFP_KERNEL);
    if (!rtdm_dev->dev) {
        EC_MASTER_ERR(master, "Failed to reserve memory for RTDM device.\n");
        return -ENOMEM;
    }
    
    devlabel = kzalloc(RTDM_MAX_DEVNAME_LEN+1, GFP_KERNEL);
    if (!devlabel) {
        EC_MASTER_ERR(master, "Failed to reserve memory for RTDM device name.\n");
        return -ENOMEM;
        kfree(rtdm_dev->dev);
    }
    snprintf(devlabel, RTDM_MAX_DEVNAME_LEN,
            "EtherCAT%u", master->index);

    rtdm_dev->dev->label = devlabel;
    rtdm_dev->dev->driver = &ec_rtdm_driver;
    rtdm_dev->dev->device_data = rtdm_dev; /* pointer to parent */


    EC_MASTER_INFO(master, "Registering RTDM device %s.\n",
            devlabel);
    ret = rtdm_dev_register(rtdm_dev->dev);
    if (ret) {
        EC_MASTER_ERR(master, "Initialization of RTDM interface failed"
                " (return value %i).\n", ret);
        kfree(rtdm_dev->dev->label);
        kfree(rtdm_dev->dev);
    }

    return ret;
}

/****************************************************************************/

/** Clear an RTDM device.
 */
void ec_rtdm_dev_clear(
        ec_rtdm_dev_t *rtdm_dev /**< EtherCAT RTDM device. */
        )
{
    EC_MASTER_INFO(rtdm_dev->master, "Unregistering RTDM device %s.\n",
            rtdm_dev->dev->label);
    rtdm_dev_unregister(rtdm_dev->dev);

    kfree(rtdm_dev->dev->label);
    kfree(rtdm_dev->dev);
}

/****************************************************************************/

/** Driver open.
 *
 * \return Always zero (success).
 */
int ec_rtdm_open(
        struct rtdm_fd *fd, /**< User data. */
        int oflags /**< Open flags. */
        )
{
    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);
#if DEBUG
    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) rtdm_fd_device(fd)->device_data;
#endif

    ctx->writable = oflags & O_WRONLY || oflags & O_RDWR;
    ctx->requested = 0;
    ctx->process_data = NULL;
    ctx->process_data_size = 0;

#if DEBUG
    EC_MASTER_INFO(rtdm_dev->master, "RTDM device %s opened.\n",
            context->device->device_name);
#endif
    return 0;
}

/****************************************************************************/

/** Driver close.
 *
 * \return Always zero (success).
 */
void ec_rtdm_close(
        struct rtdm_fd *fd /**< User data. */
        )
{
    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);
    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) rtdm_fd_device(fd)->device_data;

    if (ctx->requested) {
        ecrt_release_master(rtdm_dev->master);
	}

#if DEBUG
    EC_MASTER_INFO(rtdm_dev->master, "RTDM device %s closed.\n",
            context->device->device_name);
#endif
}

/****************************************************************************/

/** Driver ioctl.
 *
 * \return ioctl() return code.
 */
int ec_rtdm_rt_ioctl(
        struct rtdm_fd *fd, /**< User data. */
        unsigned int request, /**< Request. */
        void __user *arg /**< Argument. */
        )
{
    switch (request) {
        /*
            Requests to be handled directly in primary domain
            
            Note: list was made by selecting calls in ioctl.c 
                  that seems not to make calls forbiden in primary mode
        */
        case EC_IOCTL_MASTER_RESCAN:
        case EC_IOCTL_SEND:
        case EC_IOCTL_RECEIVE:
        case EC_IOCTL_MASTER_STATE:
        case EC_IOCTL_MASTER_LINK_STATE:
        case EC_IOCTL_APP_TIME:
        case EC_IOCTL_SYNC_REF:
        case EC_IOCTL_SYNC_SLAVES:
        case EC_IOCTL_REF_CLOCK_TIME:
        case EC_IOCTL_SYNC_MON_QUEUE:
        case EC_IOCTL_SYNC_MON_PROCESS:
        case EC_IOCTL_SC_EMERG_POP:
        case EC_IOCTL_SC_EMERG_CLEAR:
        case EC_IOCTL_SC_EMERG_OVERRUNS:
        case EC_IOCTL_SC_STATE:
        case EC_IOCTL_DOMAIN_STATE:
        case EC_IOCTL_DOMAIN_PROCESS:
        case EC_IOCTL_DOMAIN_QUEUE:
        case EC_IOCTL_SDO_REQUEST_INDEX:
        case EC_IOCTL_SDO_REQUEST_TIMEOUT:
        case EC_IOCTL_SDO_REQUEST_STATE:
        case EC_IOCTL_SDO_REQUEST_READ:
        case EC_IOCTL_SDO_REQUEST_WRITE:
        case EC_IOCTL_SDO_REQUEST_DATA:
        case EC_IOCTL_REG_REQUEST_DATA:
        case EC_IOCTL_REG_REQUEST_STATE:
        case EC_IOCTL_REG_REQUEST_WRITE:
        case EC_IOCTL_REG_REQUEST_READ:
        case EC_IOCTL_VOE_SEND_HEADER:
        case EC_IOCTL_VOE_REC_HEADER:
        case EC_IOCTL_VOE_READ:
        case EC_IOCTL_VOE_READ_NOSYNC:
        case EC_IOCTL_VOE_WRITE:
        case EC_IOCTL_VOE_EXEC:
        case EC_IOCTL_VOE_DATA:
            return ec_rtdm_ioctl(fd, request, arg);
        default:
            break;
    }
    /* When a call is not supposed to happen in primary domain,
       syscall catches -ENOSYS, then switch to secondary mode,
       and calls .ioctl_nrt */
    return -ENOSYS;
}

int ec_rtdm_ioctl(
        struct rtdm_fd *fd, /**< User data. */
        unsigned int request, /**< Request. */
        void __user *arg /**< Argument. */
        )
{
    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);
    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) rtdm_fd_device(fd)->device_data;

#if DEBUG
    EC_MASTER_INFO(rtdm_dev->master, "ioctl(request = %u, ctl = %02x)"
            " on RTDM device %s.\n", request, _IOC_NR(request),
            context->device->device_name);
#endif
    return ec_ioctl_rtdm(rtdm_dev->master, ctx, request, arg);
}

/****************************************************************************/

/** Memory-map process data to user space.
 *
 */
int ec_rtdm_mmap(struct rtdm_fd *fd, struct vm_area_struct *vma)
{
	size_t len;
    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);
	len = vma->vm_end - vma->vm_start;
	return rtdm_mmap_kmem(vma, (void *)ctx->process_data);
}

/****************************************************************************/