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