2 * FTDI FT232BM Device emulation
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
8 * This code is licensed under the LGPL.
11 #include "qemu/osdep.h"
12 #include "qapi/error.h"
13 #include "qemu-common.h"
14 #include "qemu/cutils.h"
15 #include "qemu/error-report.h"
17 #include "hw/usb/desc.h"
18 #include "sysemu/char.h"
20 //#define DEBUG_Serial
23 #define DPRINTF(fmt, ...) \
24 do { printf("usb-serial: " fmt , ## __VA_ARGS__); } while (0)
26 #define DPRINTF(fmt, ...) do {} while(0)
33 #define FTDI_SET_MDM_CTRL 1
34 #define FTDI_SET_FLOW_CTRL 2
35 #define FTDI_SET_BAUD 3
36 #define FTDI_SET_DATA 4
37 #define FTDI_GET_MDM_ST 5
38 #define FTDI_SET_EVENT_CHR 6
39 #define FTDI_SET_ERROR_CHR 7
40 #define FTDI_SET_LATENCY 9
41 #define FTDI_GET_LATENCY 10
43 #define DeviceOutVendor ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
44 #define DeviceInVendor ((USB_DIR_IN |USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
48 #define FTDI_RESET_SIO 0
49 #define FTDI_RESET_RX 1
50 #define FTDI_RESET_TX 2
55 #define FTDI_SET_DTR (FTDI_DTR << 8)
57 #define FTDI_SET_RTS (FTDI_RTS << 8)
61 #define FTDI_RTS_CTS_HS 1
62 #define FTDI_DTR_DSR_HS 2
63 #define FTDI_XON_XOFF_HS 4
67 #define FTDI_PARITY (0x7 << 8)
68 #define FTDI_ODD (0x1 << 8)
69 #define FTDI_EVEN (0x2 << 8)
70 #define FTDI_MARK (0x3 << 8)
71 #define FTDI_SPACE (0x4 << 8)
73 #define FTDI_STOP (0x3 << 11)
74 #define FTDI_STOP1 (0x0 << 11)
75 #define FTDI_STOP15 (0x1 << 11)
76 #define FTDI_STOP2 (0x2 << 11)
79 /* TODO: should be sent every 40ms */
80 #define FTDI_CTS (1<<4) // CTS line status
81 #define FTDI_DSR (1<<5) // DSR line status
82 #define FTDI_RI (1<<6) // RI line status
83 #define FTDI_RLSD (1<<7) // Receive Line Signal Detect
87 #define FTDI_DR (1<<0) // Data Ready
88 #define FTDI_OE (1<<1) // Overrun Err
89 #define FTDI_PE (1<<2) // Parity Err
90 #define FTDI_FE (1<<3) // Framing Err
91 #define FTDI_BI (1<<4) // Break Interrupt
92 #define FTDI_THRE (1<<5) // Transmitter Holding Register
93 #define FTDI_TEMT (1<<6) // Transmitter Empty
94 #define FTDI_FIFO (1<<7) // Error in FIFO
98 uint8_t recv_buf
[RECV_BUF
];
103 uint8_t event_trigger
;
104 QEMUSerialSetParams params
;
105 int latency
; /* ms */
109 #define TYPE_USB_SERIAL "usb-serial-dev"
110 #define USB_SERIAL_DEV(obj) OBJECT_CHECK(USBSerialState, (obj), TYPE_USB_SERIAL)
113 STR_MANUFACTURER
= 1,
119 static const USBDescStrings desc_strings
= {
120 [STR_MANUFACTURER
] = "QEMU",
121 [STR_PRODUCT_SERIAL
] = "QEMU USB SERIAL",
122 [STR_PRODUCT_BRAILLE
] = "QEMU USB BAUM BRAILLE",
123 [STR_SERIALNUMBER
] = "1",
126 static const USBDescIface desc_iface0
= {
127 .bInterfaceNumber
= 0,
129 .bInterfaceClass
= 0xff,
130 .bInterfaceSubClass
= 0xff,
131 .bInterfaceProtocol
= 0xff,
132 .eps
= (USBDescEndpoint
[]) {
134 .bEndpointAddress
= USB_DIR_IN
| 0x01,
135 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
136 .wMaxPacketSize
= 64,
138 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
139 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
140 .wMaxPacketSize
= 64,
145 static const USBDescDevice desc_device
= {
147 .bMaxPacketSize0
= 8,
148 .bNumConfigurations
= 1,
149 .confs
= (USBDescConfig
[]) {
152 .bConfigurationValue
= 1,
153 .bmAttributes
= USB_CFG_ATT_ONE
,
161 static const USBDesc desc_serial
= {
166 .iManufacturer
= STR_MANUFACTURER
,
167 .iProduct
= STR_PRODUCT_SERIAL
,
168 .iSerialNumber
= STR_SERIALNUMBER
,
170 .full
= &desc_device
,
174 static const USBDesc desc_braille
= {
179 .iManufacturer
= STR_MANUFACTURER
,
180 .iProduct
= STR_PRODUCT_BRAILLE
,
181 .iSerialNumber
= STR_SERIALNUMBER
,
183 .full
= &desc_device
,
187 static void usb_serial_reset(USBSerialState
*s
)
189 /* TODO: Set flow control to none */
191 s
->event_trigger
= 0;
194 /* TODO: purge in char driver */
197 static void usb_serial_handle_reset(USBDevice
*dev
)
199 USBSerialState
*s
= (USBSerialState
*)dev
;
204 /* TODO: Reset char device, send BREAK? */
207 static uint8_t usb_get_modem_lines(USBSerialState
*s
)
212 if (qemu_chr_fe_ioctl(s
->cs
, CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
) == -ENOTSUP
)
213 return FTDI_CTS
|FTDI_DSR
|FTDI_RLSD
;
216 if (flags
& CHR_TIOCM_CTS
)
218 if (flags
& CHR_TIOCM_DSR
)
220 if (flags
& CHR_TIOCM_RI
)
222 if (flags
& CHR_TIOCM_CAR
)
228 static void usb_serial_handle_control(USBDevice
*dev
, USBPacket
*p
,
229 int request
, int value
, int index
, int length
, uint8_t *data
)
231 USBSerialState
*s
= (USBSerialState
*)dev
;
234 DPRINTF("got control %x, value %x\n",request
, value
);
235 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
241 case EndpointOutRequest
| USB_REQ_CLEAR_FEATURE
:
244 /* Class specific requests. */
245 case DeviceOutVendor
| FTDI_RESET
:
253 /* TODO: purge from char device */
256 /* TODO: purge from char device */
260 case DeviceOutVendor
| FTDI_SET_MDM_CTRL
:
263 qemu_chr_fe_ioctl(s
->cs
,CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
);
264 if (value
& FTDI_SET_RTS
) {
265 if (value
& FTDI_RTS
)
266 flags
|= CHR_TIOCM_RTS
;
268 flags
&= ~CHR_TIOCM_RTS
;
270 if (value
& FTDI_SET_DTR
) {
271 if (value
& FTDI_DTR
)
272 flags
|= CHR_TIOCM_DTR
;
274 flags
&= ~CHR_TIOCM_DTR
;
276 qemu_chr_fe_ioctl(s
->cs
,CHR_IOCTL_SERIAL_SET_TIOCM
, &flags
);
279 case DeviceOutVendor
| FTDI_SET_FLOW_CTRL
:
282 case DeviceOutVendor
| FTDI_SET_BAUD
: {
283 static const int subdivisors8
[8] = { 0, 4, 2, 1, 3, 5, 6, 7 };
284 int subdivisor8
= subdivisors8
[((value
& 0xc000) >> 14)
285 | ((index
& 1) << 2)];
286 int divisor
= value
& 0x3fff;
288 /* chip special cases */
289 if (divisor
== 1 && subdivisor8
== 0)
291 if (divisor
== 0 && subdivisor8
== 0)
294 s
->params
.speed
= (48000000 / 2) / (8 * divisor
+ subdivisor8
);
295 qemu_chr_fe_ioctl(s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
298 case DeviceOutVendor
| FTDI_SET_DATA
:
299 switch (value
& FTDI_PARITY
) {
301 s
->params
.parity
= 'N';
304 s
->params
.parity
= 'O';
307 s
->params
.parity
= 'E';
310 DPRINTF("unsupported parity %d\n", value
& FTDI_PARITY
);
313 switch (value
& FTDI_STOP
) {
315 s
->params
.stop_bits
= 1;
318 s
->params
.stop_bits
= 2;
321 DPRINTF("unsupported stop bits %d\n", value
& FTDI_STOP
);
324 qemu_chr_fe_ioctl(s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
325 /* TODO: TX ON/OFF */
327 case DeviceInVendor
| FTDI_GET_MDM_ST
:
328 data
[0] = usb_get_modem_lines(s
) | 1;
330 p
->actual_length
= 2;
332 case DeviceOutVendor
| FTDI_SET_EVENT_CHR
:
333 /* TODO: handle it */
334 s
->event_chr
= value
;
336 case DeviceOutVendor
| FTDI_SET_ERROR_CHR
:
337 /* TODO: handle it */
338 s
->error_chr
= value
;
340 case DeviceOutVendor
| FTDI_SET_LATENCY
:
343 case DeviceInVendor
| FTDI_GET_LATENCY
:
344 data
[0] = s
->latency
;
345 p
->actual_length
= 1;
349 DPRINTF("got unsupported/bogus control %x, value %x\n", request
, value
);
350 p
->status
= USB_RET_STALL
;
355 static void usb_serial_handle_data(USBDevice
*dev
, USBPacket
*p
)
357 USBSerialState
*s
= (USBSerialState
*)dev
;
358 uint8_t devep
= p
->ep
->nr
;
361 int i
, first_len
, len
;
367 for (i
= 0; i
< p
->iov
.niov
; i
++) {
368 iov
= p
->iov
.iov
+ i
;
369 /* XXX this blocks entire thread. Rewrite to use
370 * qemu_chr_fe_write and background I/O callbacks */
371 qemu_chr_fe_write_all(s
->cs
, iov
->iov_base
, iov
->iov_len
);
373 p
->actual_length
= p
->iov
.size
;
379 first_len
= RECV_BUF
- s
->recv_ptr
;
382 p
->status
= USB_RET_NAK
;
385 header
[0] = usb_get_modem_lines(s
) | 1;
386 /* We do not have the uart details */
387 /* handle serial break */
388 if (s
->event_trigger
&& s
->event_trigger
& FTDI_BI
) {
389 s
->event_trigger
&= ~FTDI_BI
;
391 usb_packet_copy(p
, header
, 2);
397 if (len
> s
->recv_used
)
400 p
->status
= USB_RET_NAK
;
405 usb_packet_copy(p
, header
, 2);
406 usb_packet_copy(p
, s
->recv_buf
+ s
->recv_ptr
, first_len
);
408 usb_packet_copy(p
, s
->recv_buf
, len
- first_len
);
410 s
->recv_ptr
= (s
->recv_ptr
+ len
) % RECV_BUF
;
414 DPRINTF("Bad token\n");
416 p
->status
= USB_RET_STALL
;
421 static int usb_serial_can_read(void *opaque
)
423 USBSerialState
*s
= opaque
;
425 if (!s
->dev
.attached
) {
428 return RECV_BUF
- s
->recv_used
;
431 static void usb_serial_read(void *opaque
, const uint8_t *buf
, int size
)
433 USBSerialState
*s
= opaque
;
434 int first_size
, start
;
436 /* room in the buffer? */
437 if (size
> (RECV_BUF
- s
->recv_used
))
438 size
= RECV_BUF
- s
->recv_used
;
440 start
= s
->recv_ptr
+ s
->recv_used
;
441 if (start
< RECV_BUF
) {
442 /* copy data to end of buffer */
443 first_size
= RECV_BUF
- start
;
444 if (first_size
> size
)
447 memcpy(s
->recv_buf
+ start
, buf
, first_size
);
449 /* wrap around to front if needed */
450 if (size
> first_size
)
451 memcpy(s
->recv_buf
, buf
+ first_size
, size
- first_size
);
454 memcpy(s
->recv_buf
+ start
, buf
, size
);
456 s
->recv_used
+= size
;
459 static void usb_serial_event(void *opaque
, int event
)
461 USBSerialState
*s
= opaque
;
464 case CHR_EVENT_BREAK
:
465 s
->event_trigger
|= FTDI_BI
;
467 case CHR_EVENT_FOCUS
:
469 case CHR_EVENT_OPENED
:
470 if (!s
->dev
.attached
) {
471 usb_device_attach(&s
->dev
, &error_abort
);
474 case CHR_EVENT_CLOSED
:
475 if (s
->dev
.attached
) {
476 usb_device_detach(&s
->dev
);
482 static void usb_serial_realize(USBDevice
*dev
, Error
**errp
)
484 USBSerialState
*s
= USB_SERIAL_DEV(dev
);
485 Error
*local_err
= NULL
;
487 usb_desc_create_serial(dev
);
489 dev
->auto_attach
= 0;
492 error_setg(errp
, "Property chardev is required");
496 usb_check_attach(dev
, &local_err
);
498 error_propagate(errp
, local_err
);
502 qemu_chr_add_handlers(s
->cs
, usb_serial_can_read
, usb_serial_read
,
503 usb_serial_event
, s
);
504 usb_serial_handle_reset(dev
);
506 if (s
->cs
->be_open
&& !dev
->attached
) {
507 usb_device_attach(dev
, &error_abort
);
511 static USBDevice
*usb_serial_init(USBBus
*bus
, const char *filename
)
514 CharDriverState
*cdrv
;
515 uint32_t vendorid
= 0, productid
= 0;
519 while (*filename
&& *filename
!= ':') {
522 if (strstart(filename
, "vendorid=", &p
)) {
523 vendorid
= strtol(p
, &e
, 16);
524 if (e
== p
|| (*e
&& *e
!= ',' && *e
!= ':')) {
525 error_report("bogus vendor ID %s", p
);
529 } else if (strstart(filename
, "productid=", &p
)) {
530 productid
= strtol(p
, &e
, 16);
531 if (e
== p
|| (*e
&& *e
!= ',' && *e
!= ':')) {
532 error_report("bogus product ID %s", p
);
537 error_report("unrecognized serial USB option %s", filename
);
540 while(*filename
== ',')
544 error_report("character device specification needed");
549 snprintf(label
, sizeof(label
), "usbserial%d", index
++);
550 cdrv
= qemu_chr_new(label
, filename
, NULL
);
554 dev
= usb_create(bus
, "usb-serial");
555 qdev_prop_set_chr(&dev
->qdev
, "chardev", cdrv
);
557 qdev_prop_set_uint16(&dev
->qdev
, "vendorid", vendorid
);
559 qdev_prop_set_uint16(&dev
->qdev
, "productid", productid
);
563 static USBDevice
*usb_braille_init(USBBus
*bus
, const char *unused
)
566 CharDriverState
*cdrv
;
568 cdrv
= qemu_chr_new("braille", "braille", NULL
);
572 dev
= usb_create(bus
, "usb-braille");
573 qdev_prop_set_chr(&dev
->qdev
, "chardev", cdrv
);
577 static const VMStateDescription vmstate_usb_serial
= {
578 .name
= "usb-serial",
582 static Property serial_properties
[] = {
583 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
584 DEFINE_PROP_END_OF_LIST(),
587 static void usb_serial_dev_class_init(ObjectClass
*klass
, void *data
)
589 DeviceClass
*dc
= DEVICE_CLASS(klass
);
590 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
592 uc
->realize
= usb_serial_realize
;
593 uc
->handle_reset
= usb_serial_handle_reset
;
594 uc
->handle_control
= usb_serial_handle_control
;
595 uc
->handle_data
= usb_serial_handle_data
;
596 dc
->vmsd
= &vmstate_usb_serial
;
597 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
600 static const TypeInfo usb_serial_dev_type_info
= {
601 .name
= TYPE_USB_SERIAL
,
602 .parent
= TYPE_USB_DEVICE
,
603 .instance_size
= sizeof(USBSerialState
),
605 .class_init
= usb_serial_dev_class_init
,
608 static void usb_serial_class_initfn(ObjectClass
*klass
, void *data
)
610 DeviceClass
*dc
= DEVICE_CLASS(klass
);
611 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
613 uc
->product_desc
= "QEMU USB Serial";
614 uc
->usb_desc
= &desc_serial
;
615 dc
->props
= serial_properties
;
618 static const TypeInfo serial_info
= {
619 .name
= "usb-serial",
620 .parent
= TYPE_USB_SERIAL
,
621 .class_init
= usb_serial_class_initfn
,
624 static Property braille_properties
[] = {
625 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
626 DEFINE_PROP_END_OF_LIST(),
629 static void usb_braille_class_initfn(ObjectClass
*klass
, void *data
)
631 DeviceClass
*dc
= DEVICE_CLASS(klass
);
632 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
634 uc
->product_desc
= "QEMU USB Braille";
635 uc
->usb_desc
= &desc_braille
;
636 dc
->props
= braille_properties
;
639 static const TypeInfo braille_info
= {
640 .name
= "usb-braille",
641 .parent
= TYPE_USB_SERIAL
,
642 .class_init
= usb_braille_class_initfn
,
645 static void usb_serial_register_types(void)
647 type_register_static(&usb_serial_dev_type_info
);
648 type_register_static(&serial_info
);
649 usb_legacy_register("usb-serial", "serial", usb_serial_init
);
650 type_register_static(&braille_info
);
651 usb_legacy_register("usb-braille", "braille", usb_braille_init
);
654 type_init(usb_serial_register_types
)