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