/*

   * Copyright 2010 Tilera Corporation. All Rights Reserved.

   *

   *   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, version 2.

   *

   *   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, GOOD TITLE or
   *   NON INFRINGEMENT.  See the GNU General Public License for
   *   more details.

   *
   * Tilera TILE Processor hypervisor console
   */
  
  #include <linux/console.h>
  #include <linux/delay.h>
  #include <linux/err.h>
  #include <linux/init.h>

  #include <linux/interrupt.h>
  #include <linux/irq.h>

  #include <linux/moduleparam.h>

  #include <linux/platform_device.h>

  #include <linux/types.h>

  #include <asm/setup.h>
  #include <arch/sim_def.h>

  #include <hv/hypervisor.h>
  
  #include "hvc_console.h"

  static int use_sim_console;
  static int __init sim_console(char *str)
  {
  	use_sim_console = 1;
  	return 0;
  }
  early_param("sim_console", sim_console);
  
  int tile_console_write(const char *buf, int count)
  {
  	if (unlikely(use_sim_console)) {
  		int i;
  		for (i = 0; i < count; ++i)
  			__insn_mtspr(SPR_SIM_CONTROL, SIM_CONTROL_PUTC |
  				     (buf[i] << _SIM_CONTROL_OPERATOR_BITS));
  		__insn_mtspr(SPR_SIM_CONTROL, SIM_CONTROL_PUTC |
  			     (SIM_PUTC_FLUSH_BINARY <<
  			      _SIM_CONTROL_OPERATOR_BITS));
  		return 0;
  	} else {

  		/* Translate 0 bytes written to EAGAIN for hvc_console_print. */
  		return hv_console_write((HV_VirtAddr)buf, count) ?: -EAGAIN;

  	}
  }

  static int hvc_tile_put_chars(uint32_t vt, const char *buf, int count)
  {

  	return tile_console_write(buf, count);

  }
  
  static int hvc_tile_get_chars(uint32_t vt, char *buf, int count)
  {
  	int i, c;
  
  	for (i = 0; i < count; ++i) {
  		c = hv_console_read_if_ready();
  		if (c < 0)
  			break;
  		buf[i] = c;
  	}
  
  	return i;
  }

  #ifdef __tilegx__
  /*
   * IRQ based callbacks.
   */
  static int hvc_tile_notifier_add_irq(struct hvc_struct *hp, int irq)
  {
  	int rc;
  	int cpu = raw_smp_processor_id();  /* Choose an arbitrary cpu */
  	HV_Coord coord = { .x = cpu_x(cpu), .y = cpu_y(cpu) };
  
  	rc = notifier_add_irq(hp, irq);
  	if (rc)
  		return rc;
  
  	/*
  	 * Request that the hypervisor start sending us interrupts.
  	 * If the hypervisor returns an error, we still return 0, so that
  	 * we can fall back to polling.
  	 */
  	if (hv_console_set_ipi(KERNEL_PL, irq, coord) < 0)
  		notifier_del_irq(hp, irq);
  
  	return 0;
  }
  
  static void hvc_tile_notifier_del_irq(struct hvc_struct *hp, int irq)
  {
  	HV_Coord coord = { 0, 0 };
  
  	/* Tell the hypervisor to stop sending us interrupts. */
  	hv_console_set_ipi(KERNEL_PL, -1, coord);
  
  	notifier_del_irq(hp, irq);
  }
  
  static void hvc_tile_notifier_hangup_irq(struct hvc_struct *hp, int irq)
  {
  	hvc_tile_notifier_del_irq(hp, irq);
  }
  #endif

  static const struct hv_ops hvc_tile_get_put_ops = {
  	.get_chars = hvc_tile_get_chars,
  	.put_chars = hvc_tile_put_chars,

  #ifdef __tilegx__
  	.notifier_add = hvc_tile_notifier_add_irq,
  	.notifier_del = hvc_tile_notifier_del_irq,
  	.notifier_hangup = hvc_tile_notifier_hangup_irq,
  #endif
  };
  
  
  #ifdef __tilegx__
  static int hvc_tile_probe(struct platform_device *pdev)
  {
  	struct hvc_struct *hp;
  	int tile_hvc_irq;
  
  	/* Create our IRQ and register it. */

  	tile_hvc_irq = irq_alloc_hwirq(-1);
  	if (!tile_hvc_irq)

  		return -ENXIO;
  
  	tile_irq_activate(tile_hvc_irq, TILE_IRQ_PERCPU);
  	hp = hvc_alloc(0, tile_hvc_irq, &hvc_tile_get_put_ops, 128);
  	if (IS_ERR(hp)) {

  		irq_free_hwirq(tile_hvc_irq);

  		return PTR_ERR(hp);
  	}
  	dev_set_drvdata(&pdev->dev, hp);
  
  	return 0;
  }
  
  static int hvc_tile_remove(struct platform_device *pdev)
  {
  	int rc;
  	struct hvc_struct *hp = dev_get_drvdata(&pdev->dev);
  
  	rc = hvc_remove(hp);
  	if (rc == 0)

  		irq_free_hwirq(hp->data);

  
  	return rc;
  }
  
  static void hvc_tile_shutdown(struct platform_device *pdev)
  {
  	struct hvc_struct *hp = dev_get_drvdata(&pdev->dev);
  
  	hvc_tile_notifier_del_irq(hp, hp->data);
  }
  
  static struct platform_device hvc_tile_pdev = {
  	.name           = "hvc-tile",
  	.id             = 0,
  };
  
  static struct platform_driver hvc_tile_driver = {
  	.probe          = hvc_tile_probe,
  	.remove         = hvc_tile_remove,
  	.shutdown	= hvc_tile_shutdown,
  	.driver         = {
  		.name   = "hvc-tile",

  	}

  };

  #endif

  
  static int __init hvc_tile_console_init(void)
  {

  	hvc_instantiate(0, 0, &hvc_tile_get_put_ops);
  	add_preferred_console("hvc", 0, NULL);

  	return 0;
  }
  console_initcall(hvc_tile_console_init);
  
  static int __init hvc_tile_init(void)
  {

  #ifndef __tilegx__
  	struct hvc_struct *hp;
  	hp = hvc_alloc(0, 0, &hvc_tile_get_put_ops, 128);

  	return PTR_ERR_OR_ZERO(hp);

  #else
  	platform_device_register(&hvc_tile_pdev);
  	return platform_driver_register(&hvc_tile_driver);
  #endif

  }
  device_initcall(hvc_tile_init);