/* $Id: init.c,v 1.68.2.5 2009/01/23 17:21:20 mikpe Exp $

 * Performance-monitoring counters driver.

 * Top-level initialisation code.

 *

 * Copyright (C) 1999-2007, 2009  Mikael Pettersson

 */

#include <linux/version.h>

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)

#include <linux/config.h>

#endif

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/init.h>

#include <linux/miscdevice.h>

#include <linux/sched.h>

#include <linux/perfctr.h>

#include <asm/uaccess.h>

#include "compat.h"

#include "virtual.h"

#include "global.h"

#include "version.h"

#include "marshal.h"

MODULE_AUTHOR("Mikael Pettersson <mikpe@it.uu.se>");

MODULE_DESCRIPTION("Performance-monitoring counters driver");

MODULE_LICENSE("GPL");

MODULE_ALIAS("char-major-10-182");

#ifdef CONFIG_PERFCTR_DEBUG

#define VERSION_DEBUG " DEBUG"

#else

#define VERSION_DEBUG

#endif

struct perfctr_info perfctr_info = {

	.abi_version = PERFCTR_ABI_VERSION,

	.driver_version = VERSION VERSION_DEBUG,

};

char *perfctr_cpu_name __initdata;

int sys_perfctr_abi(unsigned int *argp)

{

	if( put_user(PERFCTR_ABI_VERSION, argp) )

		return -EFAULT;

	return 0;

}

int sys_perfctr_info(struct perfctr_struct_buf *argp)

{

	return perfctr_copy_to_user(argp, &perfctr_info, &perfctr_info_sdesc);

}

static int cpus_copy_to_user(const cpumask_t *cpus, struct perfctr_cpu_mask *argp)

{

	const unsigned int k_nrwords = PERFCTR_CPUMASK_NRLONGS*(sizeof(long)/sizeof(int));

	unsigned int u_nrwords;

	unsigned int ui, ki, j;

	if( get_user(u_nrwords, &argp->nrwords) )

		return -EFAULT;

	if( put_user(k_nrwords, &argp->nrwords) )

		return -EFAULT;

	if( u_nrwords < k_nrwords )

		return -EOVERFLOW;

	for(ui = 0, ki = 0; ki < PERFCTR_CPUMASK_NRLONGS; ++ki) {

		unsigned long mask = cpus_addr(*cpus)[ki];

		for(j = 0; j < sizeof(long)/sizeof(int); ++j) {

			if( put_user((unsigned int)mask, &argp->mask[ui]) )

				return -EFAULT;

			++ui;

			mask = (mask >> (8*sizeof(int)-1)) >> 1;

		}

	}

	return 0;

}

int sys_perfctr_cpus(struct perfctr_cpu_mask *argp)

{

	cpumask_t cpus = cpu_online_map;

	return cpus_copy_to_user(&cpus, argp);

}

int sys_perfctr_cpus_forbidden(struct perfctr_cpu_mask *argp)

{

	cpumask_t cpus = perfctr_cpus_forbidden_mask;

	return cpus_copy_to_user(&cpus, argp);

}

#if defined(CONFIG_IA32_EMULATION) && !HAVE_COMPAT_IOCTL

#include <asm/ioctl32.h>

static void __init perfctr_register_ioctl32_conversions(void)

{

	int err;

	err  = register_ioctl32_conversion(PERFCTR_ABI, 0);

	err |= register_ioctl32_conversion(PERFCTR_INFO, 0);

	err |= register_ioctl32_conversion(PERFCTR_CPUS, 0);

	err |= register_ioctl32_conversion(PERFCTR_CPUS_FORBIDDEN, 0);

	err |= register_ioctl32_conversion(VPERFCTR_CREAT, 0);

	err |= register_ioctl32_conversion(VPERFCTR_OPEN, 0);

	err |= register_ioctl32_conversion(VPERFCTR_READ_SUM, 0);

	err |= register_ioctl32_conversion(VPERFCTR_UNLINK, 0);

	err |= register_ioctl32_conversion(VPERFCTR_CONTROL, 0);

	err |= register_ioctl32_conversion(VPERFCTR_IRESUME, 0);

	err |= register_ioctl32_conversion(VPERFCTR_READ_CONTROL, 0);

	err |= register_ioctl32_conversion(GPERFCTR_CONTROL, 0);

	err |= register_ioctl32_conversion(GPERFCTR_READ, 0);

	err |= register_ioctl32_conversion(GPERFCTR_STOP, 0);

	err |= register_ioctl32_conversion(GPERFCTR_START, 0);

	if( err )

		printk(KERN_ERR "perfctr: register_ioctl32_conversion() failed\n");

}

static void __exit perfctr_unregister_ioctl32_conversions(void)

{

	unregister_ioctl32_conversion(PERFCTR_ABI);

	unregister_ioctl32_conversion(PERFCTR_INFO);

	unregister_ioctl32_conversion(PERFCTR_CPUS);

	unregister_ioctl32_conversion(PERFCTR_CPUS_FORBIDDEN);

	unregister_ioctl32_conversion(VPERFCTR_CREAT);

	unregister_ioctl32_conversion(VPERFCTR_OPEN);

	unregister_ioctl32_conversion(VPERFCTR_READ_SUM);

	unregister_ioctl32_conversion(VPERFCTR_UNLINK);

	unregister_ioctl32_conversion(VPERFCTR_CONTROL);

	unregister_ioctl32_conversion(VPERFCTR_IRESUME);

	unregister_ioctl32_conversion(VPERFCTR_READ_CONTROL);

	unregister_ioctl32_conversion(GPERFCTR_CONTROL);

	unregister_ioctl32_conversion(GPERFCTR_READ);

	unregister_ioctl32_conversion(GPERFCTR_STOP);

	unregister_ioctl32_conversion(GPERFCTR_START);

}

#else

#define perfctr_register_ioctl32_conversions()		do{}while(0)

#define perfctr_unregister_ioctl32_conversions()	do{}while(0)

#endif

static long dev_perfctr_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

	switch( cmd ) {

	case PERFCTR_ABI:

		return sys_perfctr_abi((unsigned int*)arg);

	case PERFCTR_INFO:

		return sys_perfctr_info((struct perfctr_struct_buf*)arg);

	case PERFCTR_CPUS:

		return sys_perfctr_cpus((struct perfctr_cpu_mask*)arg);

	case PERFCTR_CPUS_FORBIDDEN:

		return sys_perfctr_cpus_forbidden((struct perfctr_cpu_mask*)arg);

	case VPERFCTR_CREAT:

		return vperfctr_attach((int)arg, 1);

	case VPERFCTR_OPEN:

		return vperfctr_attach((int)arg, 0);

	default:

		return gperfctr_ioctl(filp, cmd, arg);

	}

	return -EINVAL;

}

#if !HAVE_UNLOCKED_IOCTL

static int dev_perfctr_ioctl_oldstyle(struct inode *inode, struct file *filp,

				      unsigned int cmd, unsigned long arg)

{

	return dev_perfctr_ioctl(filp, cmd, arg);

}

#endif

static struct file_operations dev_perfctr_file_ops = {

	.owner = THIS_MODULE,

	/* 2.6.11-rc2 introduced HAVE_UNLOCKED_IOCTL and HAVE_COMPAT_IOCTL */

#if HAVE_UNLOCKED_IOCTL

	.unlocked_ioctl = dev_perfctr_ioctl,

#else

	.ioctl = dev_perfctr_ioctl_oldstyle,

#endif

#if defined(CONFIG_IA32_EMULATION) && HAVE_COMPAT_IOCTL

	.compat_ioctl = dev_perfctr_ioctl,

#endif

};

static struct miscdevice dev_perfctr = {

	.minor = 182,

	.name = "perfctr",

	.fops = &dev_perfctr_file_ops,

};

int __init perfctr_init(void)

{

	int err;

	if( (err = perfctr_cpu_init()) != 0 ) {

		printk(KERN_INFO "perfctr: not supported by this processor\n");

		return err;

	}

	if( (err = vperfctr_init()) != 0 )

		return err;

	gperfctr_init();

	if( (err = misc_register(&dev_perfctr)) != 0 ) {

		printk(KERN_ERR "/dev/perfctr: failed to register, errno %d\n",

		       -err);

		return err;

	}

	perfctr_register_ioctl32_conversions();

	printk(KERN_INFO "perfctr: driver %s, cpu type %s at %u kHz\n",

	       perfctr_info.driver_version,

	       perfctr_cpu_name,

	       perfctr_info.cpu_khz);

	return 0;

}

void __exit perfctr_exit(void)

{

	perfctr_unregister_ioctl32_conversions();

	misc_deregister(&dev_perfctr);

	vperfctr_exit();

	perfctr_cpu_exit();

}

module_init(perfctr_init)

module_exit(perfctr_exit)