/*
 * This file is part of the Xenomai project.
 *
 * Copyright (C) 2014 Philippe Gerum <rpm@xenomai.org>
 *
 * This program 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; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/gfp.h>
#include <linux/vmalloc.h>
#include <rtdm/driver.h>
#include <cobalt/kernel/vdso.h>
#include "process.h"
#include "memory.h"

#define UMM_PRIVATE  0	/* Per-process user-mapped memory heap */
#define UMM_SHARED   1	/* Shared user-mapped memory heap */
#define SYS_GLOBAL   2	/* System heap (not mmapped) */

struct xnvdso *nkvdso;
EXPORT_SYMBOL_GPL(nkvdso);

static void umm_vmopen(struct vm_area_struct *vma)
{
	struct cobalt_umm *umm = vma->vm_private_data;

	atomic_inc(&umm->refcount);
}

static void umm_vmclose(struct vm_area_struct *vma)
{
	struct cobalt_umm *umm = vma->vm_private_data;

	cobalt_umm_destroy(umm);
}

static struct vm_operations_struct umm_vmops = {
	.open = umm_vmopen,
	.close = umm_vmclose,
};

static struct cobalt_umm *umm_from_fd(struct rtdm_fd *fd)
{
	struct cobalt_process *process;

	process = cobalt_current_process();
	if (process == NULL)
		return NULL;

	if (rtdm_fd_minor(fd) == UMM_PRIVATE)
		return &process->sys_ppd.umm;

	return &cobalt_kernel_ppd.umm;
}

static int umm_mmap(struct rtdm_fd *fd, struct vm_area_struct *vma)
{
	struct cobalt_umm *umm;
	size_t len;
	int ret;

	umm = umm_from_fd(fd);
	if (fd == NULL)
		return -ENODEV;

	len = vma->vm_end - vma->vm_start;
	if (len != xnheap_get_size(&umm->heap))
		return -EINVAL;

	vma->vm_private_data = umm;
	vma->vm_ops = &umm_vmops;
	if (xnarch_cache_aliasing())
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	ret = rtdm_mmap_vmem(vma, xnheap_get_membase(&umm->heap));
	if (ret)
		return ret;

	atomic_inc(&umm->refcount);

	return 0;
}

#ifndef CONFIG_MMU
static unsigned long umm_get_unmapped_area(struct rtdm_fd *fd,
					   unsigned long len,
					   unsigned long pgoff,
					   unsigned long flags)
{
	struct cobalt_umm *umm;

	umm = umm_from_fd(fd);
	if (umm == NULL)
		return -ENODEV;

	if (pgoff == 0)
		return (unsigned long)xnheap_get_membase(&umm->heap);

	return pgoff << PAGE_SHIFT;
}
#else
#define umm_get_unmapped_area	NULL
#endif

static int stat_umm(struct rtdm_fd *fd,
		    struct cobalt_umm __user *u_stat)
{
	struct cobalt_memdev_stat stat;
	struct cobalt_umm *umm;
	spl_t s;
	
	umm = umm_from_fd(fd);
	if (umm == NULL)
		return -ENODEV;

	xnlock_get_irqsave(&umm->heap.lock, s);
	stat.size = xnheap_get_size(&umm->heap);
	stat.free = xnheap_get_free(&umm->heap);
	xnlock_put_irqrestore(&umm->heap.lock, s);

	return rtdm_safe_copy_to_user(fd, u_stat, &stat, sizeof(stat));
}

static int do_umm_ioctls(struct rtdm_fd *fd,
			 unsigned int request, void __user *arg)
{
	int ret;

	switch (request) {
	case MEMDEV_RTIOC_STAT:
		ret = stat_umm(fd, arg);
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}

static int umm_ioctl_rt(struct rtdm_fd *fd,
			unsigned int request, void __user *arg)
{
	return do_umm_ioctls(fd, request, arg);
}

static int umm_ioctl_nrt(struct rtdm_fd *fd,
			 unsigned int request, void __user *arg)
{
	return do_umm_ioctls(fd, request, arg);
}

static int sysmem_open(struct rtdm_fd *fd, int oflags)
{
	if ((oflags & O_ACCMODE) != O_RDONLY)
		return -EACCES;

	return 0;
}

static int do_sysmem_ioctls(struct rtdm_fd *fd,
			    unsigned int request, void __user *arg)
{
	struct cobalt_memdev_stat stat;
	spl_t s;
	int ret;

	switch (request) {
	case MEMDEV_RTIOC_STAT:
		xnlock_get_irqsave(&cobalt_heap.lock, s);
		stat.size = xnheap_get_size(&cobalt_heap);
		stat.free = xnheap_get_free(&cobalt_heap);
		xnlock_put_irqrestore(&cobalt_heap.lock, s);
		ret = rtdm_safe_copy_to_user(fd, arg, &stat, sizeof(stat));
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}

static int sysmem_ioctl_rt(struct rtdm_fd *fd,
			   unsigned int request, void __user *arg)
{
	return do_sysmem_ioctls(fd, request, arg);
}

static int sysmem_ioctl_nrt(struct rtdm_fd *fd,
			   unsigned int request, void __user *arg)
{
	return do_sysmem_ioctls(fd, request, arg);
}

static struct rtdm_driver umm_driver = {
	.profile_info	=	RTDM_PROFILE_INFO(umm,
						  RTDM_CLASS_MEMORY,
						  RTDM_SUBCLASS_GENERIC,
						  0),
	.device_flags	=	RTDM_NAMED_DEVICE|RTDM_FIXED_MINOR,
	.device_count	=	2,
	.ops = {
		.ioctl_rt		=	umm_ioctl_rt,
		.ioctl_nrt		=	umm_ioctl_nrt,
		.mmap			=	umm_mmap,
		.get_unmapped_area	=	umm_get_unmapped_area,
	},
};

static struct rtdm_device umm_devices[] = {
	[ UMM_PRIVATE ] = {
		.driver = &umm_driver,
		.label = COBALT_MEMDEV_PRIVATE,
		.minor = UMM_PRIVATE,
	},
	[ UMM_SHARED ] = {
		.driver = &umm_driver,
		.label = COBALT_MEMDEV_SHARED,
		.minor = UMM_SHARED,
	},
};

static struct rtdm_driver sysmem_driver = {
	.profile_info	=	RTDM_PROFILE_INFO(sysmem,
						  RTDM_CLASS_MEMORY,
						  SYS_GLOBAL,
						  0),
	.device_flags	=	RTDM_NAMED_DEVICE,
	.device_count	=	1,
	.ops = {
		.open		=	sysmem_open,
		.ioctl_rt	=	sysmem_ioctl_rt,
		.ioctl_nrt	=	sysmem_ioctl_nrt,
	},
};

static struct rtdm_device sysmem_device = {
	.driver = &sysmem_driver,
	.label = COBALT_MEMDEV_SYS,
};

static inline void init_vdso(void)
{
	nkvdso->features = XNVDSO_FEATURES;
	nkvdso->wallclock_offset = nkclock.wallclock_offset;
}

int cobalt_memdev_init(void)
{
	int ret;

	ret = cobalt_umm_init(&cobalt_kernel_ppd.umm,
			      CONFIG_XENO_OPT_SHARED_HEAPSZ * 1024, NULL);
	if (ret)
		return ret;

	cobalt_umm_set_name(&cobalt_kernel_ppd.umm, "shared heap");

	nkvdso = cobalt_umm_alloc(&cobalt_kernel_ppd.umm, sizeof(*nkvdso));
	if (nkvdso == NULL) {
		ret = -ENOMEM;
		goto fail_vdso;
	}

	init_vdso();

	ret = rtdm_dev_register(umm_devices + UMM_PRIVATE);
	if (ret)
		goto fail_private;

	ret = rtdm_dev_register(umm_devices + UMM_SHARED);
	if (ret)
		goto fail_shared;

	ret = rtdm_dev_register(&sysmem_device);
	if (ret)
		goto fail_sysmem;

	return 0;

fail_sysmem:
	rtdm_dev_unregister(umm_devices + UMM_SHARED);
fail_shared:
	rtdm_dev_unregister(umm_devices + UMM_PRIVATE);
fail_private:
	cobalt_umm_free(&cobalt_kernel_ppd.umm, nkvdso);
fail_vdso:
	cobalt_umm_destroy(&cobalt_kernel_ppd.umm);

	return ret;
}

void cobalt_memdev_cleanup(void)
{
	rtdm_dev_unregister(&sysmem_device);
	rtdm_dev_unregister(umm_devices + UMM_SHARED);
	rtdm_dev_unregister(umm_devices + UMM_PRIVATE);
	cobalt_umm_free(&cobalt_kernel_ppd.umm, nkvdso);
	cobalt_umm_destroy(&cobalt_kernel_ppd.umm);
}

int cobalt_umm_init(struct cobalt_umm *umm, u32 size,
		    void (*release)(struct cobalt_umm *umm))
{
	void *basemem;
	int ret;

	secondary_mode_only();

	/* We don't support CPUs with VIVT caches and the like. */
	BUG_ON(xnarch_cache_aliasing());

	size = PAGE_ALIGN(size);
	basemem = vmalloc_kernel(size, __GFP_ZERO);
	if (basemem == NULL)
		return -ENOMEM;

	ret = xnheap_init(&umm->heap, basemem, size);
	if (ret) {
		vfree(basemem);
		return ret;
	}

	umm->release = release;
	atomic_set(&umm->refcount, 1);
	smp_mb();

	return 0;
}

void cobalt_umm_destroy(struct cobalt_umm *umm)
{
	secondary_mode_only();

	if (atomic_dec_and_test(&umm->refcount)) {
		xnheap_destroy(&umm->heap);
		vfree(xnheap_get_membase(&umm->heap));
		if (umm->release)
			umm->release(umm);
	}
}