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