1 /* 2 * FTDI FT232BM Device emulation 3 * 4 * Copyright (c) 2006 CodeSourcery. 5 * Copyright (c) 2008 Samuel Thibault <samuel.thibault@ens-lyon.org> 6 * Written by Paul Brook, reused for FTDI by Samuel Thibault 7 * 8 * This code is licensed under the LGPL. 9 */ 10 11 #include "qemu/osdep.h" 12 #include "qapi/error.h" 13 #include "qemu/cutils.h" 14 #include "qemu/error-report.h" 15 #include "qemu/module.h" 16 #include "hw/qdev-properties.h" 17 #include "hw/usb.h" 18 #include "migration/vmstate.h" 19 #include "desc.h" 20 #include "chardev/char-serial.h" 21 #include "chardev/char-fe.h" 22 #include "qom/object.h" 23 24 //#define DEBUG_Serial 25 26 #ifdef DEBUG_Serial 27 #define DPRINTF(fmt, ...) \ 28 do { printf("usb-serial: " fmt , ## __VA_ARGS__); } while (0) 29 #else 30 #define DPRINTF(fmt, ...) do {} while(0) 31 #endif 32 33 #define RECV_BUF (512 - (2 * 8)) 34 35 /* Commands */ 36 #define FTDI_RESET 0 37 #define FTDI_SET_MDM_CTRL 1 38 #define FTDI_SET_FLOW_CTRL 2 39 #define FTDI_SET_BAUD 3 40 #define FTDI_SET_DATA 4 41 #define FTDI_GET_MDM_ST 5 42 #define FTDI_SET_EVENT_CHR 6 43 #define FTDI_SET_ERROR_CHR 7 44 #define FTDI_SET_LATENCY 9 45 #define FTDI_GET_LATENCY 10 46 47 #define DeviceOutVendor ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8) 48 #define DeviceInVendor ((USB_DIR_IN |USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8) 49 50 /* RESET */ 51 52 #define FTDI_RESET_SIO 0 53 #define FTDI_RESET_RX 1 54 #define FTDI_RESET_TX 2 55 56 /* SET_MDM_CTRL */ 57 58 #define FTDI_DTR 1 59 #define FTDI_SET_DTR (FTDI_DTR << 8) 60 #define FTDI_RTS 2 61 #define FTDI_SET_RTS (FTDI_RTS << 8) 62 63 /* SET_FLOW_CTRL */ 64 65 #define FTDI_RTS_CTS_HS 1 66 #define FTDI_DTR_DSR_HS 2 67 #define FTDI_XON_XOFF_HS 4 68 69 /* SET_DATA */ 70 71 #define FTDI_PARITY (0x7 << 8) 72 #define FTDI_ODD (0x1 << 8) 73 #define FTDI_EVEN (0x2 << 8) 74 #define FTDI_MARK (0x3 << 8) 75 #define FTDI_SPACE (0x4 << 8) 76 77 #define FTDI_STOP (0x3 << 11) 78 #define FTDI_STOP1 (0x0 << 11) 79 #define FTDI_STOP15 (0x1 << 11) 80 #define FTDI_STOP2 (0x2 << 11) 81 82 /* GET_MDM_ST */ 83 /* TODO: should be sent every 40ms */ 84 #define FTDI_CTS (1<<4) // CTS line status 85 #define FTDI_DSR (1<<5) // DSR line status 86 #define FTDI_RI (1<<6) // RI line status 87 #define FTDI_RLSD (1<<7) // Receive Line Signal Detect 88 89 /* Status */ 90 91 #define FTDI_DR (1<<0) // Data Ready 92 #define FTDI_OE (1<<1) // Overrun Err 93 #define FTDI_PE (1<<2) // Parity Err 94 #define FTDI_FE (1<<3) // Framing Err 95 #define FTDI_BI (1<<4) // Break Interrupt 96 #define FTDI_THRE (1<<5) // Transmitter Holding Register 97 #define FTDI_TEMT (1<<6) // Transmitter Empty 98 #define FTDI_FIFO (1<<7) // Error in FIFO 99 100 struct USBSerialState { 101 USBDevice dev; 102 USBEndpoint *intr; 103 uint8_t recv_buf[RECV_BUF]; 104 uint16_t recv_ptr; 105 uint16_t recv_used; 106 uint8_t event_chr; 107 uint8_t error_chr; 108 uint8_t event_trigger; 109 QEMUSerialSetParams params; 110 int latency; /* ms */ 111 CharBackend cs; 112 }; 113 typedef struct USBSerialState USBSerialState; 114 115 #define TYPE_USB_SERIAL "usb-serial-dev" 116 #define USB_SERIAL_DEV(obj) OBJECT_CHECK(USBSerialState, (obj), TYPE_USB_SERIAL) 117 118 enum { 119 STR_MANUFACTURER = 1, 120 STR_PRODUCT_SERIAL, 121 STR_PRODUCT_BRAILLE, 122 STR_SERIALNUMBER, 123 }; 124 125 static const USBDescStrings desc_strings = { 126 [STR_MANUFACTURER] = "QEMU", 127 [STR_PRODUCT_SERIAL] = "QEMU USB SERIAL", 128 [STR_PRODUCT_BRAILLE] = "QEMU USB BAUM BRAILLE", 129 [STR_SERIALNUMBER] = "1", 130 }; 131 132 static const USBDescIface desc_iface0 = { 133 .bInterfaceNumber = 0, 134 .bNumEndpoints = 2, 135 .bInterfaceClass = 0xff, 136 .bInterfaceSubClass = 0xff, 137 .bInterfaceProtocol = 0xff, 138 .eps = (USBDescEndpoint[]) { 139 { 140 .bEndpointAddress = USB_DIR_IN | 0x01, 141 .bmAttributes = USB_ENDPOINT_XFER_BULK, 142 .wMaxPacketSize = 64, 143 },{ 144 .bEndpointAddress = USB_DIR_OUT | 0x02, 145 .bmAttributes = USB_ENDPOINT_XFER_BULK, 146 .wMaxPacketSize = 64, 147 }, 148 } 149 }; 150 151 static const USBDescDevice desc_device = { 152 .bcdUSB = 0x0200, 153 .bMaxPacketSize0 = 8, 154 .bNumConfigurations = 1, 155 .confs = (USBDescConfig[]) { 156 { 157 .bNumInterfaces = 1, 158 .bConfigurationValue = 1, 159 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_WAKEUP, 160 .bMaxPower = 50, 161 .nif = 1, 162 .ifs = &desc_iface0, 163 }, 164 }, 165 }; 166 167 static const USBDesc desc_serial = { 168 .id = { 169 .idVendor = 0x0403, 170 .idProduct = 0x6001, 171 .bcdDevice = 0x0400, 172 .iManufacturer = STR_MANUFACTURER, 173 .iProduct = STR_PRODUCT_SERIAL, 174 .iSerialNumber = STR_SERIALNUMBER, 175 }, 176 .full = &desc_device, 177 .str = desc_strings, 178 }; 179 180 static const USBDesc desc_braille = { 181 .id = { 182 .idVendor = 0x0403, 183 .idProduct = 0xfe72, 184 .bcdDevice = 0x0400, 185 .iManufacturer = STR_MANUFACTURER, 186 .iProduct = STR_PRODUCT_BRAILLE, 187 .iSerialNumber = STR_SERIALNUMBER, 188 }, 189 .full = &desc_device, 190 .str = desc_strings, 191 }; 192 193 static void usb_serial_reset(USBSerialState *s) 194 { 195 /* TODO: Set flow control to none */ 196 s->event_chr = 0x0d; 197 s->event_trigger = 0; 198 s->recv_ptr = 0; 199 s->recv_used = 0; 200 /* TODO: purge in char driver */ 201 } 202 203 static void usb_serial_handle_reset(USBDevice *dev) 204 { 205 USBSerialState *s = (USBSerialState *)dev; 206 207 DPRINTF("Reset\n"); 208 209 usb_serial_reset(s); 210 /* TODO: Reset char device, send BREAK? */ 211 } 212 213 static uint8_t usb_get_modem_lines(USBSerialState *s) 214 { 215 int flags; 216 uint8_t ret; 217 218 if (qemu_chr_fe_ioctl(&s->cs, 219 CHR_IOCTL_SERIAL_GET_TIOCM, &flags) == -ENOTSUP) { 220 return FTDI_CTS|FTDI_DSR|FTDI_RLSD; 221 } 222 223 ret = 0; 224 if (flags & CHR_TIOCM_CTS) 225 ret |= FTDI_CTS; 226 if (flags & CHR_TIOCM_DSR) 227 ret |= FTDI_DSR; 228 if (flags & CHR_TIOCM_RI) 229 ret |= FTDI_RI; 230 if (flags & CHR_TIOCM_CAR) 231 ret |= FTDI_RLSD; 232 233 return ret; 234 } 235 236 static void usb_serial_handle_control(USBDevice *dev, USBPacket *p, 237 int request, int value, int index, int length, uint8_t *data) 238 { 239 USBSerialState *s = (USBSerialState *)dev; 240 int ret; 241 242 DPRINTF("got control %x, value %x\n",request, value); 243 ret = usb_desc_handle_control(dev, p, request, value, index, length, data); 244 if (ret >= 0) { 245 return; 246 } 247 248 switch (request) { 249 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE: 250 break; 251 252 /* Class specific requests. */ 253 case DeviceOutVendor | FTDI_RESET: 254 switch (value) { 255 case FTDI_RESET_SIO: 256 usb_serial_reset(s); 257 break; 258 case FTDI_RESET_RX: 259 s->recv_ptr = 0; 260 s->recv_used = 0; 261 /* TODO: purge from char device */ 262 break; 263 case FTDI_RESET_TX: 264 /* TODO: purge from char device */ 265 break; 266 } 267 break; 268 case DeviceOutVendor | FTDI_SET_MDM_CTRL: 269 { 270 static int flags; 271 qemu_chr_fe_ioctl(&s->cs, CHR_IOCTL_SERIAL_GET_TIOCM, &flags); 272 if (value & FTDI_SET_RTS) { 273 if (value & FTDI_RTS) 274 flags |= CHR_TIOCM_RTS; 275 else 276 flags &= ~CHR_TIOCM_RTS; 277 } 278 if (value & FTDI_SET_DTR) { 279 if (value & FTDI_DTR) 280 flags |= CHR_TIOCM_DTR; 281 else 282 flags &= ~CHR_TIOCM_DTR; 283 } 284 qemu_chr_fe_ioctl(&s->cs, CHR_IOCTL_SERIAL_SET_TIOCM, &flags); 285 break; 286 } 287 case DeviceOutVendor | FTDI_SET_FLOW_CTRL: 288 /* TODO: ioctl */ 289 break; 290 case DeviceOutVendor | FTDI_SET_BAUD: { 291 static const int subdivisors8[8] = { 0, 4, 2, 1, 3, 5, 6, 7 }; 292 int subdivisor8 = subdivisors8[((value & 0xc000) >> 14) 293 | ((index & 1) << 2)]; 294 int divisor = value & 0x3fff; 295 296 /* chip special cases */ 297 if (divisor == 1 && subdivisor8 == 0) 298 subdivisor8 = 4; 299 if (divisor == 0 && subdivisor8 == 0) 300 divisor = 1; 301 302 s->params.speed = (48000000 / 2) / (8 * divisor + subdivisor8); 303 qemu_chr_fe_ioctl(&s->cs, CHR_IOCTL_SERIAL_SET_PARAMS, &s->params); 304 break; 305 } 306 case DeviceOutVendor | FTDI_SET_DATA: 307 switch (value & FTDI_PARITY) { 308 case 0: 309 s->params.parity = 'N'; 310 break; 311 case FTDI_ODD: 312 s->params.parity = 'O'; 313 break; 314 case FTDI_EVEN: 315 s->params.parity = 'E'; 316 break; 317 default: 318 DPRINTF("unsupported parity %d\n", value & FTDI_PARITY); 319 goto fail; 320 } 321 switch (value & FTDI_STOP) { 322 case FTDI_STOP1: 323 s->params.stop_bits = 1; 324 break; 325 case FTDI_STOP2: 326 s->params.stop_bits = 2; 327 break; 328 default: 329 DPRINTF("unsupported stop bits %d\n", value & FTDI_STOP); 330 goto fail; 331 } 332 qemu_chr_fe_ioctl(&s->cs, CHR_IOCTL_SERIAL_SET_PARAMS, &s->params); 333 /* TODO: TX ON/OFF */ 334 break; 335 case DeviceInVendor | FTDI_GET_MDM_ST: 336 data[0] = usb_get_modem_lines(s) | 1; 337 data[1] = FTDI_THRE | FTDI_TEMT; 338 p->actual_length = 2; 339 break; 340 case DeviceOutVendor | FTDI_SET_EVENT_CHR: 341 /* TODO: handle it */ 342 s->event_chr = value; 343 break; 344 case DeviceOutVendor | FTDI_SET_ERROR_CHR: 345 /* TODO: handle it */ 346 s->error_chr = value; 347 break; 348 case DeviceOutVendor | FTDI_SET_LATENCY: 349 s->latency = value; 350 break; 351 case DeviceInVendor | FTDI_GET_LATENCY: 352 data[0] = s->latency; 353 p->actual_length = 1; 354 break; 355 default: 356 fail: 357 DPRINTF("got unsupported/bogus control %x, value %x\n", request, value); 358 p->status = USB_RET_STALL; 359 break; 360 } 361 } 362 363 static void usb_serial_token_in(USBSerialState *s, USBPacket *p) 364 { 365 const int max_packet_size = desc_iface0.eps[0].wMaxPacketSize; 366 int packet_len; 367 uint8_t header[2]; 368 369 packet_len = p->iov.size; 370 if (packet_len <= 2) { 371 p->status = USB_RET_NAK; 372 return; 373 } 374 375 header[0] = usb_get_modem_lines(s) | 1; 376 /* We do not have the uart details */ 377 /* handle serial break */ 378 if (s->event_trigger && s->event_trigger & FTDI_BI) { 379 s->event_trigger &= ~FTDI_BI; 380 header[1] = FTDI_BI; 381 usb_packet_copy(p, header, 2); 382 return; 383 } else { 384 header[1] = 0; 385 } 386 387 if (!s->recv_used) { 388 p->status = USB_RET_NAK; 389 return; 390 } 391 392 while (s->recv_used && packet_len > 2) { 393 int first_len, len; 394 395 len = MIN(packet_len, max_packet_size); 396 len -= 2; 397 if (len > s->recv_used) { 398 len = s->recv_used; 399 } 400 401 first_len = RECV_BUF - s->recv_ptr; 402 if (first_len > len) { 403 first_len = len; 404 } 405 usb_packet_copy(p, header, 2); 406 usb_packet_copy(p, s->recv_buf + s->recv_ptr, first_len); 407 if (len > first_len) { 408 usb_packet_copy(p, s->recv_buf, len - first_len); 409 } 410 s->recv_used -= len; 411 s->recv_ptr = (s->recv_ptr + len) % RECV_BUF; 412 packet_len -= len + 2; 413 } 414 415 return; 416 } 417 418 static void usb_serial_handle_data(USBDevice *dev, USBPacket *p) 419 { 420 USBSerialState *s = (USBSerialState *)dev; 421 uint8_t devep = p->ep->nr; 422 struct iovec *iov; 423 int i; 424 425 switch (p->pid) { 426 case USB_TOKEN_OUT: 427 if (devep != 2) 428 goto fail; 429 for (i = 0; i < p->iov.niov; i++) { 430 iov = p->iov.iov + i; 431 /* XXX this blocks entire thread. Rewrite to use 432 * qemu_chr_fe_write and background I/O callbacks */ 433 qemu_chr_fe_write_all(&s->cs, iov->iov_base, iov->iov_len); 434 } 435 p->actual_length = p->iov.size; 436 break; 437 438 case USB_TOKEN_IN: 439 if (devep != 1) 440 goto fail; 441 usb_serial_token_in(s, p); 442 break; 443 444 default: 445 DPRINTF("Bad token\n"); 446 fail: 447 p->status = USB_RET_STALL; 448 break; 449 } 450 } 451 452 static int usb_serial_can_read(void *opaque) 453 { 454 USBSerialState *s = opaque; 455 456 if (!s->dev.attached) { 457 return 0; 458 } 459 return RECV_BUF - s->recv_used; 460 } 461 462 static void usb_serial_read(void *opaque, const uint8_t *buf, int size) 463 { 464 USBSerialState *s = opaque; 465 int first_size, start; 466 467 /* room in the buffer? */ 468 if (size > (RECV_BUF - s->recv_used)) 469 size = RECV_BUF - s->recv_used; 470 471 start = s->recv_ptr + s->recv_used; 472 if (start < RECV_BUF) { 473 /* copy data to end of buffer */ 474 first_size = RECV_BUF - start; 475 if (first_size > size) 476 first_size = size; 477 478 memcpy(s->recv_buf + start, buf, first_size); 479 480 /* wrap around to front if needed */ 481 if (size > first_size) 482 memcpy(s->recv_buf, buf + first_size, size - first_size); 483 } else { 484 start -= RECV_BUF; 485 memcpy(s->recv_buf + start, buf, size); 486 } 487 s->recv_used += size; 488 489 usb_wakeup(s->intr, 0); 490 } 491 492 static void usb_serial_event(void *opaque, QEMUChrEvent event) 493 { 494 USBSerialState *s = opaque; 495 496 switch (event) { 497 case CHR_EVENT_BREAK: 498 s->event_trigger |= FTDI_BI; 499 break; 500 case CHR_EVENT_OPENED: 501 if (!s->dev.attached) { 502 usb_device_attach(&s->dev, &error_abort); 503 } 504 break; 505 case CHR_EVENT_CLOSED: 506 if (s->dev.attached) { 507 usb_device_detach(&s->dev); 508 } 509 break; 510 case CHR_EVENT_MUX_IN: 511 case CHR_EVENT_MUX_OUT: 512 /* Ignore */ 513 break; 514 } 515 } 516 517 static void usb_serial_realize(USBDevice *dev, Error **errp) 518 { 519 USBSerialState *s = USB_SERIAL_DEV(dev); 520 Error *local_err = NULL; 521 522 usb_desc_create_serial(dev); 523 usb_desc_init(dev); 524 dev->auto_attach = 0; 525 526 if (!qemu_chr_fe_backend_connected(&s->cs)) { 527 error_setg(errp, "Property chardev is required"); 528 return; 529 } 530 531 usb_check_attach(dev, &local_err); 532 if (local_err) { 533 error_propagate(errp, local_err); 534 return; 535 } 536 537 qemu_chr_fe_set_handlers(&s->cs, usb_serial_can_read, usb_serial_read, 538 usb_serial_event, NULL, s, NULL, true); 539 usb_serial_handle_reset(dev); 540 541 if (qemu_chr_fe_backend_open(&s->cs) && !dev->attached) { 542 usb_device_attach(dev, &error_abort); 543 } 544 s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1); 545 } 546 547 static USBDevice *usb_braille_init(const char *unused) 548 { 549 USBDevice *dev; 550 Chardev *cdrv; 551 552 cdrv = qemu_chr_new("braille", "braille", NULL); 553 if (!cdrv) 554 return NULL; 555 556 dev = usb_new("usb-braille"); 557 qdev_prop_set_chr(&dev->qdev, "chardev", cdrv); 558 return dev; 559 } 560 561 static const VMStateDescription vmstate_usb_serial = { 562 .name = "usb-serial", 563 .unmigratable = 1, 564 }; 565 566 static Property serial_properties[] = { 567 DEFINE_PROP_CHR("chardev", USBSerialState, cs), 568 DEFINE_PROP_END_OF_LIST(), 569 }; 570 571 static void usb_serial_dev_class_init(ObjectClass *klass, void *data) 572 { 573 DeviceClass *dc = DEVICE_CLASS(klass); 574 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 575 576 uc->realize = usb_serial_realize; 577 uc->handle_reset = usb_serial_handle_reset; 578 uc->handle_control = usb_serial_handle_control; 579 uc->handle_data = usb_serial_handle_data; 580 dc->vmsd = &vmstate_usb_serial; 581 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 582 } 583 584 static const TypeInfo usb_serial_dev_type_info = { 585 .name = TYPE_USB_SERIAL, 586 .parent = TYPE_USB_DEVICE, 587 .instance_size = sizeof(USBSerialState), 588 .abstract = true, 589 .class_init = usb_serial_dev_class_init, 590 }; 591 592 static void usb_serial_class_initfn(ObjectClass *klass, void *data) 593 { 594 DeviceClass *dc = DEVICE_CLASS(klass); 595 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 596 597 uc->product_desc = "QEMU USB Serial"; 598 uc->usb_desc = &desc_serial; 599 device_class_set_props(dc, serial_properties); 600 } 601 602 static const TypeInfo serial_info = { 603 .name = "usb-serial", 604 .parent = TYPE_USB_SERIAL, 605 .class_init = usb_serial_class_initfn, 606 }; 607 608 static Property braille_properties[] = { 609 DEFINE_PROP_CHR("chardev", USBSerialState, cs), 610 DEFINE_PROP_END_OF_LIST(), 611 }; 612 613 static void usb_braille_class_initfn(ObjectClass *klass, void *data) 614 { 615 DeviceClass *dc = DEVICE_CLASS(klass); 616 USBDeviceClass *uc = USB_DEVICE_CLASS(klass); 617 618 uc->product_desc = "QEMU USB Braille"; 619 uc->usb_desc = &desc_braille; 620 device_class_set_props(dc, braille_properties); 621 } 622 623 static const TypeInfo braille_info = { 624 .name = "usb-braille", 625 .parent = TYPE_USB_SERIAL, 626 .class_init = usb_braille_class_initfn, 627 }; 628 629 static void usb_serial_register_types(void) 630 { 631 type_register_static(&usb_serial_dev_type_info); 632 type_register_static(&serial_info); 633 type_register_static(&braille_info); 634 usb_legacy_register("usb-braille", "braille", usb_braille_init); 635 } 636 637 type_init(usb_serial_register_types) 638