xref: /kvmtool/hw/serial.c (revision 12c406a8019aecdd06be7670e44a6469b380a18f)
1 #include "kvm/8250-serial.h"
2 
3 #include "kvm/read-write.h"
4 #include "kvm/ioport.h"
5 #include "kvm/mutex.h"
6 #include "kvm/util.h"
7 #include "kvm/term.h"
8 #include "kvm/kvm.h"
9 #include "kvm/fdt.h"
10 
11 #include <linux/types.h>
12 #include <linux/serial_reg.h>
13 
14 #include <pthread.h>
15 
16 /*
17  * This fakes a U6_16550A. The fifo len needs to be 64 as the kernel
18  * expects that for autodetection.
19  */
20 #define FIFO_LEN		64
21 #define FIFO_MASK		(FIFO_LEN - 1)
22 
23 #define UART_IIR_TYPE_BITS	0xc0
24 
25 struct serial8250_device {
26 	struct mutex		mutex;
27 	u8			id;
28 
29 	u16			iobase;
30 	u8			irq;
31 	u8			irq_state;
32 	int			txcnt;
33 	int			rxcnt;
34 	int			rxdone;
35 	char			txbuf[FIFO_LEN];
36 	char			rxbuf[FIFO_LEN];
37 
38 	u8			dll;
39 	u8			dlm;
40 	u8			iir;
41 	u8			ier;
42 	u8			fcr;
43 	u8			lcr;
44 	u8			mcr;
45 	u8			lsr;
46 	u8			msr;
47 	u8			scr;
48 };
49 
50 #define SERIAL_REGS_SETTING \
51 	.iir			= UART_IIR_NO_INT, \
52 	.lsr			= UART_LSR_TEMT | UART_LSR_THRE, \
53 	.msr			= UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS, \
54 	.mcr			= UART_MCR_OUT2,
55 
56 static struct serial8250_device devices[] = {
57 	/* ttyS0 */
58 	[0]	= {
59 		.mutex			= MUTEX_INITIALIZER,
60 
61 		.id			= 0,
62 		.iobase			= 0x3f8,
63 		.irq			= 4,
64 
65 		SERIAL_REGS_SETTING
66 	},
67 	/* ttyS1 */
68 	[1]	= {
69 		.mutex			= MUTEX_INITIALIZER,
70 
71 		.id			= 1,
72 		.iobase			= 0x2f8,
73 		.irq			= 3,
74 
75 		SERIAL_REGS_SETTING
76 	},
77 	/* ttyS2 */
78 	[2]	= {
79 		.mutex			= MUTEX_INITIALIZER,
80 
81 		.id			= 2,
82 		.iobase			= 0x3e8,
83 		.irq			= 4,
84 
85 		SERIAL_REGS_SETTING
86 	},
87 	/* ttyS3 */
88 	[3]	= {
89 		.mutex			= MUTEX_INITIALIZER,
90 
91 		.id			= 3,
92 		.iobase			= 0x2e8,
93 		.irq			= 3,
94 
95 		SERIAL_REGS_SETTING
96 	},
97 };
98 
99 static void serial8250_flush_tx(struct kvm *kvm, struct serial8250_device *dev)
100 {
101 	dev->lsr |= UART_LSR_TEMT | UART_LSR_THRE;
102 
103 	if (dev->txcnt) {
104 		term_putc(dev->txbuf, dev->txcnt, dev->id);
105 		dev->txcnt = 0;
106 	}
107 }
108 
109 static void serial8250_update_irq(struct kvm *kvm, struct serial8250_device *dev)
110 {
111 	u8 iir = 0;
112 
113 	/* Handle clear rx */
114 	if (dev->lcr & UART_FCR_CLEAR_RCVR) {
115 		dev->lcr &= ~UART_FCR_CLEAR_RCVR;
116 		dev->rxcnt = dev->rxdone = 0;
117 		dev->lsr &= ~UART_LSR_DR;
118 	}
119 
120 	/* Handle clear tx */
121 	if (dev->lcr & UART_FCR_CLEAR_XMIT) {
122 		dev->lcr &= ~UART_FCR_CLEAR_XMIT;
123 		dev->txcnt = 0;
124 		dev->lsr |= UART_LSR_TEMT | UART_LSR_THRE;
125 	}
126 
127 	/* Data ready and rcv interrupt enabled ? */
128 	if ((dev->ier & UART_IER_RDI) && (dev->lsr & UART_LSR_DR))
129 		iir |= UART_IIR_RDI;
130 
131 	/* Transmitter empty and interrupt enabled ? */
132 	if ((dev->ier & UART_IER_THRI) && (dev->lsr & UART_LSR_TEMT))
133 		iir |= UART_IIR_THRI;
134 
135 	/* Now update the irq line, if necessary */
136 	if (!iir) {
137 		dev->iir = UART_IIR_NO_INT;
138 		if (dev->irq_state)
139 			kvm__irq_line(kvm, dev->irq, 0);
140 	} else {
141 		dev->iir = iir;
142 		if (!dev->irq_state)
143 			kvm__irq_line(kvm, dev->irq, 1);
144 	}
145 	dev->irq_state = iir;
146 
147 	/*
148 	 * If the kernel disabled the tx interrupt, we know that there
149 	 * is nothing more to transmit, so we can reset our tx logic
150 	 * here.
151 	 */
152 	if (!(dev->ier & UART_IER_THRI))
153 		serial8250_flush_tx(kvm, dev);
154 }
155 
156 #define SYSRQ_PENDING_NONE		0
157 
158 static int sysrq_pending;
159 
160 static void serial8250__sysrq(struct kvm *kvm, struct serial8250_device *dev)
161 {
162 	dev->lsr |= UART_LSR_DR | UART_LSR_BI;
163 	dev->rxbuf[dev->rxcnt++] = sysrq_pending;
164 	sysrq_pending	= SYSRQ_PENDING_NONE;
165 }
166 
167 static void serial8250__receive(struct kvm *kvm, struct serial8250_device *dev,
168 				bool handle_sysrq)
169 {
170 	int c;
171 
172 	if (dev->mcr & UART_MCR_LOOP)
173 		return;
174 
175 	if ((dev->lsr & UART_LSR_DR) || dev->rxcnt)
176 		return;
177 
178 	if (handle_sysrq && sysrq_pending) {
179 		serial8250__sysrq(kvm, dev);
180 		return;
181 	}
182 
183 	if (kvm->cfg.active_console != CONSOLE_8250)
184 		return;
185 
186 	while (term_readable(dev->id) &&
187 	       dev->rxcnt < FIFO_LEN) {
188 
189 		c = term_getc(kvm, dev->id);
190 
191 		if (c < 0)
192 			break;
193 		dev->rxbuf[dev->rxcnt++] = c;
194 		dev->lsr |= UART_LSR_DR;
195 	}
196 }
197 
198 void serial8250__update_consoles(struct kvm *kvm)
199 {
200 	unsigned int i;
201 
202 	for (i = 0; i < ARRAY_SIZE(devices); i++) {
203 		struct serial8250_device *dev = &devices[i];
204 
205 		mutex_lock(&dev->mutex);
206 
207 		/* Restrict sysrq injection to the first port */
208 		serial8250__receive(kvm, dev, i == 0);
209 
210 		serial8250_update_irq(kvm, dev);
211 
212 		mutex_unlock(&dev->mutex);
213 	}
214 }
215 
216 void serial8250__inject_sysrq(struct kvm *kvm, char sysrq)
217 {
218 	sysrq_pending = sysrq;
219 }
220 
221 static bool serial8250_out(struct ioport *ioport, struct kvm *kvm, u16 port,
222 			   void *data, int size)
223 {
224 	struct serial8250_device *dev = ioport->priv;
225 	u16 offset;
226 	bool ret = true;
227 	char *addr = data;
228 
229 	mutex_lock(&dev->mutex);
230 
231 	offset = port - dev->iobase;
232 
233 	switch (offset) {
234 	case UART_TX:
235 		if (dev->lcr & UART_LCR_DLAB) {
236 			dev->dll = ioport__read8(data);
237 			break;
238 		}
239 
240 		/* Loopback mode */
241 		if (dev->mcr & UART_MCR_LOOP) {
242 			if (dev->rxcnt < FIFO_LEN) {
243 				dev->rxbuf[dev->rxcnt++] = *addr;
244 				dev->lsr |= UART_LSR_DR;
245 			}
246 			break;
247 		}
248 
249 		if (dev->txcnt < FIFO_LEN) {
250 			dev->txbuf[dev->txcnt++] = *addr;
251 			dev->lsr &= ~UART_LSR_TEMT;
252 			if (dev->txcnt == FIFO_LEN / 2)
253 				dev->lsr &= ~UART_LSR_THRE;
254 			serial8250_flush_tx(kvm, dev);
255 		} else {
256 			/* Should never happpen */
257 			dev->lsr &= ~(UART_LSR_TEMT | UART_LSR_THRE);
258 		}
259 		break;
260 	case UART_IER:
261 		if (!(dev->lcr & UART_LCR_DLAB))
262 			dev->ier = ioport__read8(data) & 0x0f;
263 		else
264 			dev->dlm = ioport__read8(data);
265 		break;
266 	case UART_FCR:
267 		dev->fcr = ioport__read8(data);
268 		break;
269 	case UART_LCR:
270 		dev->lcr = ioport__read8(data);
271 		break;
272 	case UART_MCR:
273 		dev->mcr = ioport__read8(data);
274 		break;
275 	case UART_LSR:
276 		/* Factory test */
277 		break;
278 	case UART_MSR:
279 		/* Not used */
280 		break;
281 	case UART_SCR:
282 		dev->scr = ioport__read8(data);
283 		break;
284 	default:
285 		ret = false;
286 		break;
287 	}
288 
289 	serial8250_update_irq(kvm, dev);
290 
291 	mutex_unlock(&dev->mutex);
292 
293 	return ret;
294 }
295 
296 static void serial8250_rx(struct serial8250_device *dev, void *data)
297 {
298 	if (dev->rxdone == dev->rxcnt)
299 		return;
300 
301 	/* Break issued ? */
302 	if (dev->lsr & UART_LSR_BI) {
303 		dev->lsr &= ~UART_LSR_BI;
304 		ioport__write8(data, 0);
305 		return;
306 	}
307 
308 	ioport__write8(data, dev->rxbuf[dev->rxdone++]);
309 	if (dev->rxcnt == dev->rxdone) {
310 		dev->lsr &= ~UART_LSR_DR;
311 		dev->rxcnt = dev->rxdone = 0;
312 	}
313 }
314 
315 static bool serial8250_in(struct ioport *ioport, struct kvm *kvm, u16 port, void *data, int size)
316 {
317 	struct serial8250_device *dev = ioport->priv;
318 	u16 offset;
319 	bool ret = true;
320 
321 	mutex_lock(&dev->mutex);
322 
323 	offset = port - dev->iobase;
324 
325 	switch (offset) {
326 	case UART_RX:
327 		if (dev->lcr & UART_LCR_DLAB)
328 			ioport__write8(data, dev->dll);
329 		else
330 			serial8250_rx(dev, data);
331 		break;
332 	case UART_IER:
333 		if (dev->lcr & UART_LCR_DLAB)
334 			ioport__write8(data, dev->dlm);
335 		else
336 			ioport__write8(data, dev->ier);
337 		break;
338 	case UART_IIR:
339 		ioport__write8(data, dev->iir | UART_IIR_TYPE_BITS);
340 		break;
341 	case UART_LCR:
342 		ioport__write8(data, dev->lcr);
343 		break;
344 	case UART_MCR:
345 		ioport__write8(data, dev->mcr);
346 		break;
347 	case UART_LSR:
348 		ioport__write8(data, dev->lsr);
349 		break;
350 	case UART_MSR:
351 		ioport__write8(data, dev->msr);
352 		break;
353 	case UART_SCR:
354 		ioport__write8(data, dev->scr);
355 		break;
356 	default:
357 		ret = false;
358 		break;
359 	}
360 
361 	serial8250_update_irq(kvm, dev);
362 
363 	mutex_unlock(&dev->mutex);
364 
365 	return ret;
366 }
367 
368 #ifdef CONFIG_HAS_LIBFDT
369 #define DEVICE_NAME_MAX_LEN 32
370 static void serial8250_generate_fdt_node(struct ioport *ioport, void *fdt,
371 					 void (*generate_irq_prop)(void *fdt,
372 								   u8 irq))
373 {
374 	char dev_name[DEVICE_NAME_MAX_LEN];
375 	struct serial8250_device *dev = ioport->priv;
376 	u64 addr = KVM_IOPORT_AREA + dev->iobase;
377 	u64 reg_prop[] = {
378 		cpu_to_fdt64(addr),
379 		cpu_to_fdt64(8),
380 	};
381 
382 	snprintf(dev_name, DEVICE_NAME_MAX_LEN, "U6_16550A@%llx", addr);
383 
384 	_FDT(fdt_begin_node(fdt, dev_name));
385 	_FDT(fdt_property_string(fdt, "compatible", "ns16550a"));
386 	_FDT(fdt_property(fdt, "reg", reg_prop, sizeof(reg_prop)));
387 	generate_irq_prop(fdt, dev->irq);
388 	_FDT(fdt_property_cell(fdt, "clock-frequency", 1843200));
389 	_FDT(fdt_end_node(fdt));
390 }
391 #else
392 #define serial8250_generate_fdt_node	NULL
393 #endif
394 
395 static struct ioport_operations serial8250_ops = {
396 	.io_in			= serial8250_in,
397 	.io_out			= serial8250_out,
398 	.generate_fdt_node	= serial8250_generate_fdt_node,
399 };
400 
401 static int serial8250__device_init(struct kvm *kvm, struct serial8250_device *dev)
402 {
403 	int r;
404 
405 	ioport__map_irq(&dev->irq);
406 	r = ioport__register(kvm, dev->iobase, &serial8250_ops, 8, dev);
407 	kvm__irq_line(kvm, dev->irq, 0);
408 
409 	return r;
410 }
411 
412 int serial8250__init(struct kvm *kvm)
413 {
414 	unsigned int i, j;
415 	int r = 0;
416 
417 	for (i = 0; i < ARRAY_SIZE(devices); i++) {
418 		struct serial8250_device *dev = &devices[i];
419 
420 		r = serial8250__device_init(kvm, dev);
421 		if (r < 0)
422 			goto cleanup;
423 	}
424 
425 	return r;
426 cleanup:
427 	for (j = 0; j <= i; j++) {
428 		struct serial8250_device *dev = &devices[j];
429 
430 		ioport__unregister(kvm, dev->iobase);
431 	}
432 
433 	return r;
434 }
435 dev_init(serial8250__init);
436 
437 int serial8250__exit(struct kvm *kvm)
438 {
439 	unsigned int i;
440 	int r;
441 
442 	for (i = 0; i < ARRAY_SIZE(devices); i++) {
443 		struct serial8250_device *dev = &devices[i];
444 
445 		r = ioport__unregister(kvm, dev->iobase);
446 		if (r < 0)
447 			return r;
448 	}
449 
450 	return 0;
451 }
452 dev_exit(serial8250__exit);
453