hw/usb/dev-serial.c

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