1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
4 *   This program is free software; you can redistribute it and/or
5 *   modify it under the terms of the GNU General Public License
6 *   as published by the Free Software Foundation, version 2.
7 *
8 *   This program is distributed in the hope that it will be useful, but
9 *   WITHOUT ANY WARRANTY; without even the implied warranty of
10 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 *   NON INFRINGEMENT.  See the GNU General Public License for
12 *   more details.
13 *
14 * Tilera TILE Processor hypervisor console
15 */
16
17#include <linux/console.h>
18#include <linux/delay.h>
19#include <linux/err.h>
20#include <linux/init.h>
21#include <linux/interrupt.h>
22#include <linux/irq.h>
23#include <linux/moduleparam.h>
24#include <linux/platform_device.h>
25#include <linux/types.h>
26
27#include <asm/setup.h>
28#include <arch/sim_def.h>
29
30#include <hv/hypervisor.h>
31
32#include "hvc_console.h"
33
34static int use_sim_console;
35static int __init sim_console(char *str)
36{
37	use_sim_console = 1;
38	return 0;
39}
40early_param("sim_console", sim_console);
41
42int tile_console_write(const char *buf, int count)
43{
44	if (unlikely(use_sim_console)) {
45		int i;
46		for (i = 0; i < count; ++i)
47			__insn_mtspr(SPR_SIM_CONTROL, SIM_CONTROL_PUTC |
48				     (buf[i] << _SIM_CONTROL_OPERATOR_BITS));
49		__insn_mtspr(SPR_SIM_CONTROL, SIM_CONTROL_PUTC |
50			     (SIM_PUTC_FLUSH_BINARY <<
51			      _SIM_CONTROL_OPERATOR_BITS));
52		return 0;
53	} else {
54		return hv_console_write((HV_VirtAddr)buf, count);
55	}
56}
57
58static int hvc_tile_put_chars(uint32_t vt, const char *buf, int count)
59{
60	return tile_console_write(buf, count);
61}
62
63static int hvc_tile_get_chars(uint32_t vt, char *buf, int count)
64{
65	int i, c;
66
67	for (i = 0; i < count; ++i) {
68		c = hv_console_read_if_ready();
69		if (c < 0)
70			break;
71		buf[i] = c;
72	}
73
74	return i;
75}
76
77#ifdef __tilegx__
78/*
79 * IRQ based callbacks.
80 */
81static int hvc_tile_notifier_add_irq(struct hvc_struct *hp, int irq)
82{
83	int rc;
84	int cpu = raw_smp_processor_id();  /* Choose an arbitrary cpu */
85	HV_Coord coord = { .x = cpu_x(cpu), .y = cpu_y(cpu) };
86
87	rc = notifier_add_irq(hp, irq);
88	if (rc)
89		return rc;
90
91	/*
92	 * Request that the hypervisor start sending us interrupts.
93	 * If the hypervisor returns an error, we still return 0, so that
94	 * we can fall back to polling.
95	 */
96	if (hv_console_set_ipi(KERNEL_PL, irq, coord) < 0)
97		notifier_del_irq(hp, irq);
98
99	return 0;
100}
101
102static void hvc_tile_notifier_del_irq(struct hvc_struct *hp, int irq)
103{
104	HV_Coord coord = { 0, 0 };
105
106	/* Tell the hypervisor to stop sending us interrupts. */
107	hv_console_set_ipi(KERNEL_PL, -1, coord);
108
109	notifier_del_irq(hp, irq);
110}
111
112static void hvc_tile_notifier_hangup_irq(struct hvc_struct *hp, int irq)
113{
114	hvc_tile_notifier_del_irq(hp, irq);
115}
116#endif
117
118static const struct hv_ops hvc_tile_get_put_ops = {
119	.get_chars = hvc_tile_get_chars,
120	.put_chars = hvc_tile_put_chars,
121#ifdef __tilegx__
122	.notifier_add = hvc_tile_notifier_add_irq,
123	.notifier_del = hvc_tile_notifier_del_irq,
124	.notifier_hangup = hvc_tile_notifier_hangup_irq,
125#endif
126};
127
128
129#ifdef __tilegx__
130static int hvc_tile_probe(struct platform_device *pdev)
131{
132	struct hvc_struct *hp;
133	int tile_hvc_irq;
134
135	/* Create our IRQ and register it. */
136	tile_hvc_irq = irq_alloc_hwirq(-1);
137	if (!tile_hvc_irq)
138		return -ENXIO;
139
140	tile_irq_activate(tile_hvc_irq, TILE_IRQ_PERCPU);
141	hp = hvc_alloc(0, tile_hvc_irq, &hvc_tile_get_put_ops, 128);
142	if (IS_ERR(hp)) {
143		irq_free_hwirq(tile_hvc_irq);
144		return PTR_ERR(hp);
145	}
146	dev_set_drvdata(&pdev->dev, hp);
147
148	return 0;
149}
150
151static int hvc_tile_remove(struct platform_device *pdev)
152{
153	int rc;
154	struct hvc_struct *hp = dev_get_drvdata(&pdev->dev);
155
156	rc = hvc_remove(hp);
157	if (rc == 0)
158		irq_free_hwirq(hp->data);
159
160	return rc;
161}
162
163static void hvc_tile_shutdown(struct platform_device *pdev)
164{
165	struct hvc_struct *hp = dev_get_drvdata(&pdev->dev);
166
167	hvc_tile_notifier_del_irq(hp, hp->data);
168}
169
170static struct platform_device hvc_tile_pdev = {
171	.name           = "hvc-tile",
172	.id             = 0,
173};
174
175static struct platform_driver hvc_tile_driver = {
176	.probe          = hvc_tile_probe,
177	.remove         = hvc_tile_remove,
178	.shutdown	= hvc_tile_shutdown,
179	.driver         = {
180		.name   = "hvc-tile",
181	}
182};
183#endif
184
185static int __init hvc_tile_console_init(void)
186{
187	hvc_instantiate(0, 0, &hvc_tile_get_put_ops);
188	add_preferred_console("hvc", 0, NULL);
189	return 0;
190}
191console_initcall(hvc_tile_console_init);
192
193static int __init hvc_tile_init(void)
194{
195#ifndef __tilegx__
196	struct hvc_struct *hp;
197	hp = hvc_alloc(0, 0, &hvc_tile_get_put_ops, 128);
198	return PTR_ERR_OR_ZERO(hp);
199#else
200	platform_device_register(&hvc_tile_pdev);
201	return platform_driver_register(&hvc_tile_driver);
202#endif
203}
204device_initcall(hvc_tile_init);
205