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 10 #include <linux/types.h> 11 #include <linux/serial_reg.h> 12 13 #include <pthread.h> 14 15 struct serial8250_device { 16 pthread_mutex_t mutex; 17 u8 id; 18 19 u16 iobase; 20 u8 irq; 21 u8 irq_state; 22 23 u8 rbr; /* receive buffer */ 24 u8 dll; 25 u8 dlm; 26 u8 iir; 27 u8 ier; 28 u8 fcr; 29 u8 lcr; 30 u8 mcr; 31 u8 lsr; 32 u8 msr; 33 u8 scr; 34 }; 35 36 #define SERIAL_REGS_SETTING \ 37 .iir = UART_IIR_NO_INT, \ 38 .lsr = UART_LSR_TEMT | UART_LSR_THRE, \ 39 .msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS, \ 40 .mcr = UART_MCR_OUT2, 41 42 static struct serial8250_device devices[] = { 43 /* ttyS0 */ 44 [0] = { 45 .mutex = PTHREAD_MUTEX_INITIALIZER, 46 47 .id = 0, 48 .iobase = 0x3f8, 49 .irq = 4, 50 51 SERIAL_REGS_SETTING 52 }, 53 /* ttyS1 */ 54 [1] = { 55 .mutex = PTHREAD_MUTEX_INITIALIZER, 56 57 .id = 1, 58 .iobase = 0x2f8, 59 .irq = 3, 60 61 SERIAL_REGS_SETTING 62 }, 63 /* ttyS2 */ 64 [2] = { 65 .mutex = PTHREAD_MUTEX_INITIALIZER, 66 67 .id = 2, 68 .iobase = 0x3e8, 69 .irq = 4, 70 71 SERIAL_REGS_SETTING 72 }, 73 /* ttyS3 */ 74 [3] = { 75 .mutex = PTHREAD_MUTEX_INITIALIZER, 76 77 .id = 3, 78 .iobase = 0x2e8, 79 .irq = 3, 80 81 SERIAL_REGS_SETTING 82 }, 83 }; 84 85 static void serial8250_update_irq(struct kvm *kvm, struct serial8250_device *dev) 86 { 87 u8 iir = 0; 88 89 /* Data ready and rcv interrupt enabled ? */ 90 if ((dev->ier & UART_IER_RDI) && (dev->lsr & UART_LSR_DR)) 91 iir |= UART_IIR_RDI; 92 93 /* Transmitter empty and interrupt enabled ? */ 94 if ((dev->ier & UART_IER_THRI) && (dev->lsr & UART_LSR_TEMT)) 95 iir |= UART_IIR_THRI; 96 97 /* Now update the irq line, if necessary */ 98 if (!iir) { 99 dev->iir = UART_IIR_NO_INT; 100 if (dev->irq_state) 101 kvm__irq_line(kvm, dev->irq, 0); 102 } else { 103 dev->iir = iir; 104 if (!dev->irq_state) 105 kvm__irq_line(kvm, dev->irq, 1); 106 } 107 dev->irq_state = iir; 108 } 109 110 #define SYSRQ_PENDING_NONE 0 111 #define SYSRQ_PENDING_BREAK 1 112 #define SYSRQ_PENDING_CMD 2 113 114 static int sysrq_pending; 115 116 static void serial8250__sysrq(struct kvm *kvm, struct serial8250_device *dev) 117 { 118 switch (sysrq_pending) { 119 case SYSRQ_PENDING_BREAK: 120 dev->lsr |= UART_LSR_DR | UART_LSR_BI; 121 122 sysrq_pending = SYSRQ_PENDING_CMD; 123 break; 124 case SYSRQ_PENDING_CMD: 125 dev->rbr = 'p'; 126 dev->lsr |= UART_LSR_DR; 127 128 sysrq_pending = SYSRQ_PENDING_NONE; 129 break; 130 } 131 } 132 133 static void serial8250__receive(struct kvm *kvm, struct serial8250_device *dev) 134 { 135 int c; 136 137 if (dev->lsr & UART_LSR_DR) 138 return; 139 140 if (sysrq_pending) { 141 serial8250__sysrq(kvm, dev); 142 return; 143 } 144 145 if (!term_readable(CONSOLE_8250, dev->id)) 146 return; 147 148 c = term_getc(CONSOLE_8250, dev->id); 149 150 if (c < 0) 151 return; 152 153 dev->rbr = c; 154 dev->lsr |= UART_LSR_DR; 155 } 156 157 void serial8250__update_consoles(struct kvm *kvm) 158 { 159 unsigned int i; 160 161 for (i = 0; i < ARRAY_SIZE(devices); i++) { 162 struct serial8250_device *dev = &devices[i]; 163 164 mutex_lock(&dev->mutex); 165 166 serial8250__receive(kvm, dev); 167 168 serial8250_update_irq(kvm, dev); 169 170 mutex_unlock(&dev->mutex); 171 } 172 } 173 174 void serial8250__inject_sysrq(struct kvm *kvm) 175 { 176 sysrq_pending = SYSRQ_PENDING_BREAK; 177 } 178 179 static struct serial8250_device *find_device(u16 port) 180 { 181 unsigned int i; 182 183 for (i = 0; i < ARRAY_SIZE(devices); i++) { 184 struct serial8250_device *dev = &devices[i]; 185 186 if (dev->iobase == (port & ~0x7)) 187 return dev; 188 } 189 return NULL; 190 } 191 192 static bool serial8250_out(struct ioport *ioport, struct kvm *kvm, u16 port, void *data, int size) 193 { 194 struct serial8250_device *dev; 195 u16 offset; 196 bool ret = true; 197 198 dev = find_device(port); 199 if (!dev) 200 return false; 201 202 mutex_lock(&dev->mutex); 203 204 offset = port - dev->iobase; 205 206 switch (offset) { 207 case UART_TX: 208 if (!(dev->lcr & UART_LCR_DLAB)) { 209 char *addr = data; 210 211 if (!(dev->mcr & UART_MCR_LOOP)) 212 term_putc(CONSOLE_8250, addr, size, dev->id); 213 /* else FIXME: Inject data into rcv path for LOOP */ 214 215 /* 216 * Set transmitter and transmit hold register 217 * empty. We have no FIFO at the moment and 218 * on the TX side it's only interesting, when 219 * we could coalesce port io on the kernel 220 * kernel. 221 */ 222 dev->lsr |= UART_LSR_TEMT | UART_LSR_THRE; 223 break; 224 } else { 225 dev->dll = ioport__read8(data); 226 } 227 break; 228 case UART_IER: 229 if (!(dev->lcr & UART_LCR_DLAB)) 230 dev->ier = ioport__read8(data) & 0x3f; 231 else 232 dev->dlm = ioport__read8(data); 233 break; 234 case UART_FCR: 235 dev->fcr = ioport__read8(data); 236 break; 237 case UART_LCR: 238 dev->lcr = ioport__read8(data); 239 break; 240 case UART_MCR: 241 dev->mcr = ioport__read8(data); 242 break; 243 case UART_LSR: 244 /* Factory test */ 245 break; 246 case UART_MSR: 247 /* Not used */ 248 break; 249 case UART_SCR: 250 dev->scr = ioport__read8(data); 251 break; 252 default: 253 ret = false; 254 break; 255 } 256 257 serial8250_update_irq(kvm, dev); 258 259 mutex_unlock(&dev->mutex); 260 261 return ret; 262 } 263 264 static bool serial8250_in(struct ioport *ioport, struct kvm *kvm, u16 port, void *data, int size) 265 { 266 struct serial8250_device *dev; 267 u16 offset; 268 bool ret = true; 269 270 dev = find_device(port); 271 if (!dev) 272 return false; 273 274 mutex_lock(&dev->mutex); 275 276 offset = port - dev->iobase; 277 278 switch (offset) { 279 case UART_RX: 280 if (dev->lcr & UART_LCR_DLAB) { 281 ioport__write8(data, dev->dll); 282 } else { 283 ioport__write8(data, dev->rbr); 284 dev->lsr &= ~UART_LSR_DR; 285 } 286 break; 287 case UART_IER: 288 if (dev->lcr & UART_LCR_DLAB) 289 ioport__write8(data, dev->dlm); 290 else 291 ioport__write8(data, dev->ier); 292 break; 293 case UART_IIR: 294 ioport__write8(data, dev->iir); 295 break; 296 case UART_LCR: 297 ioport__write8(data, dev->lcr); 298 break; 299 case UART_MCR: 300 ioport__write8(data, dev->mcr); 301 break; 302 case UART_LSR: 303 ioport__write8(data, dev->lsr); 304 break; 305 case UART_MSR: 306 ioport__write8(data, dev->msr); 307 break; 308 case UART_SCR: 309 ioport__write8(data, dev->scr); 310 break; 311 default: 312 ret = false; 313 break; 314 } 315 316 serial8250_update_irq(kvm, dev); 317 318 mutex_unlock(&dev->mutex); 319 320 return ret; 321 } 322 323 static struct ioport_operations serial8250_ops = { 324 .io_in = serial8250_in, 325 .io_out = serial8250_out, 326 }; 327 328 static void serial8250__device_init(struct kvm *kvm, struct serial8250_device *dev) 329 { 330 ioport__register(dev->iobase, &serial8250_ops, 8, NULL); 331 kvm__irq_line(kvm, dev->irq, 0); 332 } 333 334 void serial8250__init(struct kvm *kvm) 335 { 336 unsigned int i; 337 338 for (i = 0; i < ARRAY_SIZE(devices); i++) { 339 struct serial8250_device *dev = &devices[i]; 340 341 serial8250__device_init(kvm, dev); 342 } 343 } 344