/*
   * S390 Version
   *   Copyright IBM Corp. 2002, 2011
   *   Author(s): Thomas Spatzier (tspat@de.ibm.com)
   *   Author(s): Mahesh Salgaonkar (mahesh@linux.vnet.ibm.com)
   *   Author(s): Heinz Graalfs (graalfs@linux.vnet.ibm.com)
   *   Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
   *
   * @remark Copyright 2002-2011 OProfile authors
   */
  
  #include <linux/oprofile.h>
  #include <linux/perf_event.h>
  #include <linux/init.h>
  #include <linux/errno.h>
  #include <linux/fs.h>
  #include <linux/module.h>
  #include <asm/processor.h>
  
  #include "../../../drivers/oprofile/oprof.h"
  
  extern void s390_backtrace(struct pt_regs * const regs, unsigned int depth);
  
  #ifdef CONFIG_64BIT
  
  #include "hwsampler.h"
  #include "op_counter.h"
  
  #define DEFAULT_INTERVAL	4127518
  
  #define DEFAULT_SDBT_BLOCKS	1
  #define DEFAULT_SDB_BLOCKS	511
  
  static unsigned long oprofile_hw_interval = DEFAULT_INTERVAL;
  static unsigned long oprofile_min_interval;
  static unsigned long oprofile_max_interval;
  
  static unsigned long oprofile_sdbt_blocks = DEFAULT_SDBT_BLOCKS;
  static unsigned long oprofile_sdb_blocks = DEFAULT_SDB_BLOCKS;
  
  static int hwsampler_enabled;
  static int hwsampler_running;	/* start_mutex must be held to change */
  static int hwsampler_available;
  
  static struct oprofile_operations timer_ops;
  
  struct op_counter_config counter_config;
  
  enum __force_cpu_type {
  	reserved = 0,		/* do not force */
  	timer,
  };
  static int force_cpu_type;
  
  static int set_cpu_type(const char *str, struct kernel_param *kp)
  {
  	if (!strcmp(str, "timer")) {
  		force_cpu_type = timer;
  		printk(KERN_INFO "oprofile: forcing timer to be returned "
  		                 "as cpu type
  ");
  	} else {
  		force_cpu_type = 0;
  	}
  
  	return 0;
  }
  module_param_call(cpu_type, set_cpu_type, NULL, NULL, 0);
  MODULE_PARM_DESC(cpu_type, "Force legacy basic mode sampling"
  		           "(report cpu_type \"timer\"");
  
  static int __oprofile_hwsampler_start(void)
  {
  	int retval;
  
  	retval = hwsampler_allocate(oprofile_sdbt_blocks, oprofile_sdb_blocks);
  	if (retval)
  		return retval;
  
  	retval = hwsampler_start_all(oprofile_hw_interval);
  	if (retval)
  		hwsampler_deallocate();
  
  	return retval;
  }
  
  static int oprofile_hwsampler_start(void)
  {
  	int retval;
  
  	hwsampler_running = hwsampler_enabled;
  
  	if (!hwsampler_running)
  		return timer_ops.start();
  
  	retval = perf_reserve_sampling();
  	if (retval)
  		return retval;
  
  	retval = __oprofile_hwsampler_start();
  	if (retval)
  		perf_release_sampling();
  
  	return retval;
  }
  
  static void oprofile_hwsampler_stop(void)
  {
  	if (!hwsampler_running) {
  		timer_ops.stop();
  		return;
  	}
  
  	hwsampler_stop_all();
  	hwsampler_deallocate();
  	perf_release_sampling();
  	return;
  }
  
  /*
   * File ops used for:
   * /dev/oprofile/0/enabled
   * /dev/oprofile/hwsampling/hwsampler  (cpu_type = timer)
   */
  
  static ssize_t hwsampler_read(struct file *file, char __user *buf,
  		size_t count, loff_t *offset)
  {
  	return oprofilefs_ulong_to_user(hwsampler_enabled, buf, count, offset);
  }
  
  static ssize_t hwsampler_write(struct file *file, char const __user *buf,
  		size_t count, loff_t *offset)
  {
  	unsigned long val;
  	int retval;
  
  	if (*offset)
  		return -EINVAL;
  
  	retval = oprofilefs_ulong_from_user(&val, buf, count);
  	if (retval <= 0)
  		return retval;
  
  	if (val != 0 && val != 1)
  		return -EINVAL;
  
  	if (oprofile_started)
  		/*
  		 * save to do without locking as we set
  		 * hwsampler_running in start() when start_mutex is
  		 * held
  		 */
  		return -EBUSY;
  
  	hwsampler_enabled = val;
  
  	return count;
  }
  
  static const struct file_operations hwsampler_fops = {
  	.read		= hwsampler_read,
  	.write		= hwsampler_write,
  };
  
  /*
   * File ops used for:
   * /dev/oprofile/0/count
   * /dev/oprofile/hwsampling/hw_interval  (cpu_type = timer)
   *
   * Make sure that the value is within the hardware range.
   */
  
  static ssize_t hw_interval_read(struct file *file, char __user *buf,
  				size_t count, loff_t *offset)
  {
  	return oprofilefs_ulong_to_user(oprofile_hw_interval, buf,
  					count, offset);
  }
  
  static ssize_t hw_interval_write(struct file *file, char const __user *buf,
  				 size_t count, loff_t *offset)
  {
  	unsigned long val;
  	int retval;
  
  	if (*offset)
  		return -EINVAL;
  	retval = oprofilefs_ulong_from_user(&val, buf, count);
  	if (retval <= 0)
  		return retval;
  	if (val < oprofile_min_interval)
  		oprofile_hw_interval = oprofile_min_interval;
  	else if (val > oprofile_max_interval)
  		oprofile_hw_interval = oprofile_max_interval;
  	else
  		oprofile_hw_interval = val;
  
  	return count;
  }
  
  static const struct file_operations hw_interval_fops = {
  	.read		= hw_interval_read,
  	.write		= hw_interval_write,
  };
  
  /*
   * File ops used for:
   * /dev/oprofile/0/event
   * Only a single event with number 0 is supported with this counter.
   *
   * /dev/oprofile/0/unit_mask
   * This is a dummy file needed by the user space tools.
   * No value other than 0 is accepted or returned.
   */
  
  static ssize_t hwsampler_zero_read(struct file *file, char __user *buf,
  				    size_t count, loff_t *offset)
  {
  	return oprofilefs_ulong_to_user(0, buf, count, offset);
  }
  
  static ssize_t hwsampler_zero_write(struct file *file, char const __user *buf,
  				     size_t count, loff_t *offset)
  {
  	unsigned long val;
  	int retval;
  
  	if (*offset)
  		return -EINVAL;
  
  	retval = oprofilefs_ulong_from_user(&val, buf, count);
  	if (retval <= 0)
  		return retval;
  	if (val != 0)
  		return -EINVAL;
  	return count;
  }
  
  static const struct file_operations zero_fops = {
  	.read		= hwsampler_zero_read,
  	.write		= hwsampler_zero_write,
  };
  
  /* /dev/oprofile/0/kernel file ops.  */
  
  static ssize_t hwsampler_kernel_read(struct file *file, char __user *buf,
  				     size_t count, loff_t *offset)
  {
  	return oprofilefs_ulong_to_user(counter_config.kernel,
  					buf, count, offset);
  }
  
  static ssize_t hwsampler_kernel_write(struct file *file, char const __user *buf,
  				      size_t count, loff_t *offset)
  {
  	unsigned long val;
  	int retval;
  
  	if (*offset)
  		return -EINVAL;
  
  	retval = oprofilefs_ulong_from_user(&val, buf, count);
  	if (retval <= 0)
  		return retval;
  
  	if (val != 0 && val != 1)
  		return -EINVAL;
  
  	counter_config.kernel = val;
  
  	return count;
  }
  
  static const struct file_operations kernel_fops = {
  	.read		= hwsampler_kernel_read,
  	.write		= hwsampler_kernel_write,
  };
  
  /* /dev/oprofile/0/user file ops. */
  
  static ssize_t hwsampler_user_read(struct file *file, char __user *buf,
  				   size_t count, loff_t *offset)
  {
  	return oprofilefs_ulong_to_user(counter_config.user,
  					buf, count, offset);
  }
  
  static ssize_t hwsampler_user_write(struct file *file, char const __user *buf,
  				    size_t count, loff_t *offset)
  {
  	unsigned long val;
  	int retval;
  
  	if (*offset)
  		return -EINVAL;
  
  	retval = oprofilefs_ulong_from_user(&val, buf, count);
  	if (retval <= 0)
  		return retval;
  
  	if (val != 0 && val != 1)
  		return -EINVAL;
  
  	counter_config.user = val;
  
  	return count;
  }
  
  static const struct file_operations user_fops = {
  	.read		= hwsampler_user_read,
  	.write		= hwsampler_user_write,
  };
  
  
  /*
   * File ops used for: /dev/oprofile/timer/enabled
   * The value always has to be the inverted value of hwsampler_enabled. So
   * no separate variable is created. That way we do not need locking.
   */
  
  static ssize_t timer_enabled_read(struct file *file, char __user *buf,
  				  size_t count, loff_t *offset)
  {
  	return oprofilefs_ulong_to_user(!hwsampler_enabled, buf, count, offset);
  }
  
  static ssize_t timer_enabled_write(struct file *file, char const __user *buf,
  				   size_t count, loff_t *offset)
  {
  	unsigned long val;
  	int retval;
  
  	if (*offset)
  		return -EINVAL;
  
  	retval = oprofilefs_ulong_from_user(&val, buf, count);
  	if (retval <= 0)
  		return retval;
  
  	if (val != 0 && val != 1)
  		return -EINVAL;
  
  	/* Timer cannot be disabled without having hardware sampling.  */
  	if (val == 0 && !hwsampler_available)
  		return -EINVAL;
  
  	if (oprofile_started)
  		/*
  		 * save to do without locking as we set
  		 * hwsampler_running in start() when start_mutex is
  		 * held
  		 */
  		return -EBUSY;
  
  	hwsampler_enabled = !val;
  
  	return count;
  }
  
  static const struct file_operations timer_enabled_fops = {
  	.read		= timer_enabled_read,
  	.write		= timer_enabled_write,
  };
  
  
  static int oprofile_create_hwsampling_files(struct dentry *root)
  {
  	struct dentry *dir;
  
  	dir = oprofilefs_mkdir(root, "timer");
  	if (!dir)
  		return -EINVAL;
  
  	oprofilefs_create_file(dir, "enabled", &timer_enabled_fops);
  
  	if (!hwsampler_available)
  		return 0;
  
  	/* reinitialize default values */
  	hwsampler_enabled = 1;
  	counter_config.kernel = 1;
  	counter_config.user = 1;
  
  	if (!force_cpu_type) {
  		/*
  		 * Create the counter file system.  A single virtual
  		 * counter is created which can be used to
  		 * enable/disable hardware sampling dynamically from
  		 * user space.  The user space will configure a single
  		 * counter with a single event.  The value of 'event'
  		 * and 'unit_mask' are not evaluated by the kernel code
  		 * and can only be set to 0.
  		 */
  
  		dir = oprofilefs_mkdir(root, "0");
  		if (!dir)
  			return -EINVAL;
  
  		oprofilefs_create_file(dir, "enabled", &hwsampler_fops);
  		oprofilefs_create_file(dir, "event", &zero_fops);
  		oprofilefs_create_file(dir, "count", &hw_interval_fops);
  		oprofilefs_create_file(dir, "unit_mask", &zero_fops);
  		oprofilefs_create_file(dir, "kernel", &kernel_fops);
  		oprofilefs_create_file(dir, "user", &user_fops);
  		oprofilefs_create_ulong(dir, "hw_sdbt_blocks",
  					&oprofile_sdbt_blocks);
  
  	} else {
  		/*
  		 * Hardware sampling can be used but the cpu_type is
  		 * forced to timer in order to deal with legacy user
  		 * space tools.  The /dev/oprofile/hwsampling fs is
  		 * provided in that case.
  		 */
  		dir = oprofilefs_mkdir(root, "hwsampling");
  		if (!dir)
  			return -EINVAL;
  
  		oprofilefs_create_file(dir, "hwsampler",
  				       &hwsampler_fops);
  		oprofilefs_create_file(dir, "hw_interval",
  				       &hw_interval_fops);
  		oprofilefs_create_ro_ulong(dir, "hw_min_interval",
  					   &oprofile_min_interval);
  		oprofilefs_create_ro_ulong(dir, "hw_max_interval",
  					   &oprofile_max_interval);
  		oprofilefs_create_ulong(dir, "hw_sdbt_blocks",
  					&oprofile_sdbt_blocks);
  	}
  	return 0;
  }
  
  static int oprofile_hwsampler_init(struct oprofile_operations *ops)
  {
  	/*
  	 * Initialize the timer mode infrastructure as well in order
  	 * to be able to switch back dynamically.  oprofile_timer_init
  	 * is not supposed to fail.
  	 */
  	if (oprofile_timer_init(ops))
  		BUG();
  
  	memcpy(&timer_ops, ops, sizeof(timer_ops));
  	ops->create_files = oprofile_create_hwsampling_files;
  
  	/*
  	 * If the user space tools do not support newer cpu types,
  	 * the force_cpu_type module parameter
  	 * can be used to always return \"timer\" as cpu type.
  	 */
  	if (force_cpu_type != timer) {
  		struct cpuid id;
  
  		get_cpu_id (&id);
  
  		switch (id.machine) {
  		case 0x2097: case 0x2098: ops->cpu_type = "s390/z10"; break;
  		case 0x2817: case 0x2818: ops->cpu_type = "s390/z196"; break;
  		case 0x2827: case 0x2828: ops->cpu_type = "s390/zEC12"; break;
  		default: return -ENODEV;
  		}
  	}
  
  	if (hwsampler_setup())
  		return -ENODEV;
  
  	/*
  	 * Query the range for the sampling interval from the
  	 * hardware.
  	 */
  	oprofile_min_interval = hwsampler_query_min_interval();
  	if (oprofile_min_interval == 0)
  		return -ENODEV;
  	oprofile_max_interval = hwsampler_query_max_interval();
  	if (oprofile_max_interval == 0)
  		return -ENODEV;
  
  	/* The initial value should be sane */
  	if (oprofile_hw_interval < oprofile_min_interval)
  		oprofile_hw_interval = oprofile_min_interval;
  	if (oprofile_hw_interval > oprofile_max_interval)
  		oprofile_hw_interval = oprofile_max_interval;
  
  	printk(KERN_INFO "oprofile: System z hardware sampling "
  	       "facility found.
  ");
  
  	ops->start = oprofile_hwsampler_start;
  	ops->stop = oprofile_hwsampler_stop;
  
  	return 0;
  }
  
  static void oprofile_hwsampler_exit(void)
  {
  	hwsampler_shutdown();
  }
  
  #endif /* CONFIG_64BIT */
  
  int __init oprofile_arch_init(struct oprofile_operations *ops)
  {
  	ops->backtrace = s390_backtrace;
  
  #ifdef CONFIG_64BIT
  
  	/*
  	 * -ENODEV is not reported to the caller.  The module itself
           * will use the timer mode sampling as fallback and this is
           * always available.
  	 */
  	hwsampler_available = oprofile_hwsampler_init(ops) == 0;
  
  	return 0;
  #else
  	return -ENODEV;
  #endif
  }
  
  void oprofile_arch_exit(void)
  {
  #ifdef CONFIG_64BIT
  	oprofile_hwsampler_exit();
  #endif
  }