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_cpu *vcpu, 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(vcpu->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(vcpu->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_cpu *vcpu, 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(vcpu->kvm, dev); 362 363 mutex_unlock(&dev->mutex); 364 365 return ret; 366 } 367 368 #ifdef CONFIG_HAS_LIBFDT 369 370 char *fdt_stdout_path = NULL; 371 372 #define DEVICE_NAME_MAX_LEN 32 373 static 374 void serial8250_generate_fdt_node(struct ioport *ioport, void *fdt, 375 void (*generate_irq_prop)(void *fdt, 376 u8 irq, 377 enum irq_type)) 378 { 379 char dev_name[DEVICE_NAME_MAX_LEN]; 380 struct serial8250_device *dev = ioport->priv; 381 u64 addr = KVM_IOPORT_AREA + dev->iobase; 382 u64 reg_prop[] = { 383 cpu_to_fdt64(addr), 384 cpu_to_fdt64(8), 385 }; 386 387 snprintf(dev_name, DEVICE_NAME_MAX_LEN, "U6_16550A@%llx", addr); 388 389 if (!fdt_stdout_path) { 390 fdt_stdout_path = malloc(strlen(dev_name) + 2); 391 /* Assumes that this node is a child of the root node. */ 392 sprintf(fdt_stdout_path, "/%s", dev_name); 393 } 394 395 _FDT(fdt_begin_node(fdt, dev_name)); 396 _FDT(fdt_property_string(fdt, "compatible", "ns16550a")); 397 _FDT(fdt_property(fdt, "reg", reg_prop, sizeof(reg_prop))); 398 generate_irq_prop(fdt, dev->irq, IRQ_TYPE_LEVEL_HIGH); 399 _FDT(fdt_property_cell(fdt, "clock-frequency", 1843200)); 400 _FDT(fdt_end_node(fdt)); 401 } 402 #else 403 #define serial8250_generate_fdt_node NULL 404 #endif 405 406 static struct ioport_operations serial8250_ops = { 407 .io_in = serial8250_in, 408 .io_out = serial8250_out, 409 .generate_fdt_node = serial8250_generate_fdt_node, 410 }; 411 412 static int serial8250__device_init(struct kvm *kvm, struct serial8250_device *dev) 413 { 414 int r; 415 416 ioport__map_irq(&dev->irq); 417 r = ioport__register(kvm, dev->iobase, &serial8250_ops, 8, dev); 418 419 return r; 420 } 421 422 int serial8250__init(struct kvm *kvm) 423 { 424 unsigned int i, j; 425 int r = 0; 426 427 for (i = 0; i < ARRAY_SIZE(devices); i++) { 428 struct serial8250_device *dev = &devices[i]; 429 430 r = serial8250__device_init(kvm, dev); 431 if (r < 0) 432 goto cleanup; 433 } 434 435 return r; 436 cleanup: 437 for (j = 0; j <= i; j++) { 438 struct serial8250_device *dev = &devices[j]; 439 440 ioport__unregister(kvm, dev->iobase); 441 } 442 443 return r; 444 } 445 dev_init(serial8250__init); 446 447 int serial8250__exit(struct kvm *kvm) 448 { 449 unsigned int i; 450 int r; 451 452 for (i = 0; i < ARRAY_SIZE(devices); i++) { 453 struct serial8250_device *dev = &devices[i]; 454 455 r = ioport__unregister(kvm, dev->iobase); 456 if (r < 0) 457 return r; 458 } 459 460 return 0; 461 } 462 dev_exit(serial8250__exit); 463