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
34 static int use_sim_console;
sim_console(char * str)35 static int __init sim_console(char *str)
36 {
37 use_sim_console = 1;
38 return 0;
39 }
40 early_param("sim_console", sim_console);
41
tile_console_write(const char * buf,int count)42 int 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
hvc_tile_put_chars(uint32_t vt,const char * buf,int count)58 static int hvc_tile_put_chars(uint32_t vt, const char *buf, int count)
59 {
60 return tile_console_write(buf, count);
61 }
62
hvc_tile_get_chars(uint32_t vt,char * buf,int count)63 static 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 */
hvc_tile_notifier_add_irq(struct hvc_struct * hp,int irq)81 static 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
hvc_tile_notifier_del_irq(struct hvc_struct * hp,int irq)102 static 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
hvc_tile_notifier_hangup_irq(struct hvc_struct * hp,int irq)112 static 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
118 static 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__
hvc_tile_probe(struct platform_device * pdev)130 static 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
hvc_tile_remove(struct platform_device * pdev)151 static 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
hvc_tile_shutdown(struct platform_device * pdev)163 static 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
170 static struct platform_device hvc_tile_pdev = {
171 .name = "hvc-tile",
172 .id = 0,
173 };
174
175 static 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
hvc_tile_console_init(void)185 static 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 }
191 console_initcall(hvc_tile_console_init);
192
hvc_tile_init(void)193 static 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 }
204 device_initcall(hvc_tile_init);
205