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