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/cutils.h"
14 #include "qemu/error-report.h"
15 #include "qemu/module.h"
16 #include "hw/qdev-properties.h"
18 #include "migration/vmstate.h"
20 #include "chardev/char-serial.h"
21 #include "chardev/char-fe.h"
22 #include "qom/object.h"
26 #define RECV_BUF (512 - (2 * 8))
30 #define FTDI_SET_MDM_CTRL 1
31 #define FTDI_SET_FLOW_CTRL 2
32 #define FTDI_SET_BAUD 3
33 #define FTDI_SET_DATA 4
34 #define FTDI_GET_MDM_ST 5
35 #define FTDI_SET_EVENT_CHR 6
36 #define FTDI_SET_ERROR_CHR 7
37 #define FTDI_SET_LATENCY 9
38 #define FTDI_GET_LATENCY 10
42 #define FTDI_RESET_SIO 0
43 #define FTDI_RESET_RX 1
44 #define FTDI_RESET_TX 2
49 #define FTDI_SET_DTR (FTDI_DTR << 8)
51 #define FTDI_SET_RTS (FTDI_RTS << 8)
56 #define FTDI_RTS_CTS_HS 1
57 #define FTDI_DTR_DSR_HS 2
58 #define FTDI_XON_XOFF_HS 4
62 #define FTDI_PARITY (0x7 << 8)
63 #define FTDI_ODD (0x1 << 8)
64 #define FTDI_EVEN (0x2 << 8)
65 #define FTDI_MARK (0x3 << 8)
66 #define FTDI_SPACE (0x4 << 8)
68 #define FTDI_STOP (0x3 << 11)
69 #define FTDI_STOP1 (0x0 << 11)
70 #define FTDI_STOP15 (0x1 << 11)
71 #define FTDI_STOP2 (0x2 << 11)
74 /* TODO: should be sent every 40ms */
75 #define FTDI_CTS (1 << 4) /* CTS line status */
76 #define FTDI_DSR (1 << 5) /* DSR line status */
77 #define FTDI_RI (1 << 6) /* RI line status */
78 #define FTDI_RLSD (1 << 7) /* Receive Line Signal Detect */
82 #define FTDI_DR (1 << 0) /* Data Ready */
83 #define FTDI_OE (1 << 1) /* Overrun Err */
84 #define FTDI_PE (1 << 2) /* Parity Err */
85 #define FTDI_FE (1 << 3) /* Framing Err */
86 #define FTDI_BI (1 << 4) /* Break Interrupt */
87 #define FTDI_THRE (1 << 5) /* Transmitter Holding Register */
88 #define FTDI_TEMT (1 << 6) /* Transmitter Empty */
89 #define FTDI_FIFO (1 << 7) /* Error in FIFO */
91 struct USBSerialState
{
95 uint8_t recv_buf
[RECV_BUF
];
100 uint8_t event_trigger
;
102 uint8_t flow_control
;
105 QEMUSerialSetParams params
;
106 int latency
; /* ms */
110 #define TYPE_USB_SERIAL "usb-serial-dev"
111 OBJECT_DECLARE_SIMPLE_TYPE(USBSerialState
, USB_SERIAL
)
114 STR_MANUFACTURER
= 1,
120 static const USBDescStrings desc_strings
= {
121 [STR_MANUFACTURER
] = "QEMU",
122 [STR_PRODUCT_SERIAL
] = "QEMU USB SERIAL",
123 [STR_PRODUCT_BRAILLE
] = "QEMU USB BAUM BRAILLE",
124 [STR_SERIALNUMBER
] = "1",
127 static const USBDescIface desc_iface0
= {
128 .bInterfaceNumber
= 0,
130 .bInterfaceClass
= 0xff,
131 .bInterfaceSubClass
= 0xff,
132 .bInterfaceProtocol
= 0xff,
133 .eps
= (USBDescEndpoint
[]) {
135 .bEndpointAddress
= USB_DIR_IN
| 0x01,
136 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
137 .wMaxPacketSize
= 64,
139 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
140 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
141 .wMaxPacketSize
= 64,
146 static const USBDescDevice desc_device
= {
148 .bMaxPacketSize0
= 8,
149 .bNumConfigurations
= 1,
150 .confs
= (USBDescConfig
[]) {
153 .bConfigurationValue
= 1,
154 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_WAKEUP
,
162 static const USBDesc desc_serial
= {
167 .iManufacturer
= STR_MANUFACTURER
,
168 .iProduct
= STR_PRODUCT_SERIAL
,
169 .iSerialNumber
= STR_SERIALNUMBER
,
171 .full
= &desc_device
,
175 static const USBDesc desc_braille
= {
180 .iManufacturer
= STR_MANUFACTURER
,
181 .iProduct
= STR_PRODUCT_BRAILLE
,
182 .iSerialNumber
= STR_SERIALNUMBER
,
184 .full
= &desc_device
,
188 static void usb_serial_set_flow_control(USBSerialState
*s
,
189 uint8_t flow_control
)
191 USBDevice
*dev
= USB_DEVICE(s
);
192 USBBus
*bus
= usb_bus_from_device(dev
);
195 s
->flow_control
= flow_control
;
196 trace_usb_serial_set_flow_control(bus
->busnr
, dev
->addr
, flow_control
);
199 static void usb_serial_set_xonxoff(USBSerialState
*s
, int xonxoff
)
201 USBDevice
*dev
= USB_DEVICE(s
);
202 USBBus
*bus
= usb_bus_from_device(dev
);
204 s
->xon
= xonxoff
& 0xff;
205 s
->xoff
= (xonxoff
>> 8) & 0xff;
207 trace_usb_serial_set_xonxoff(bus
->busnr
, dev
->addr
, s
->xon
, s
->xoff
);
210 static void usb_serial_reset(USBSerialState
*s
)
213 s
->event_trigger
= 0;
216 /* TODO: purge in char driver */
217 usb_serial_set_flow_control(s
, FTDI_NO_HS
);
220 static void usb_serial_handle_reset(USBDevice
*dev
)
222 USBSerialState
*s
= USB_SERIAL(dev
);
223 USBBus
*bus
= usb_bus_from_device(dev
);
225 trace_usb_serial_reset(bus
->busnr
, dev
->addr
);
228 /* TODO: Reset char device, send BREAK? */
231 static uint8_t usb_get_modem_lines(USBSerialState
*s
)
236 if (qemu_chr_fe_ioctl(&s
->cs
,
237 CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
) == -ENOTSUP
) {
238 return FTDI_CTS
| FTDI_DSR
| FTDI_RLSD
;
242 if (flags
& CHR_TIOCM_CTS
) {
245 if (flags
& CHR_TIOCM_DSR
) {
248 if (flags
& CHR_TIOCM_RI
) {
251 if (flags
& CHR_TIOCM_CAR
) {
258 static void usb_serial_handle_control(USBDevice
*dev
, USBPacket
*p
,
259 int request
, int value
, int index
,
260 int length
, uint8_t *data
)
262 USBSerialState
*s
= USB_SERIAL(dev
);
263 USBBus
*bus
= usb_bus_from_device(dev
);
266 trace_usb_serial_handle_control(bus
->busnr
, dev
->addr
, request
, value
);
268 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
274 case EndpointOutRequest
| USB_REQ_CLEAR_FEATURE
:
277 /* Class specific requests. */
278 case VendorDeviceOutRequest
| FTDI_RESET
:
286 /* TODO: purge from char device */
289 /* TODO: purge from char device */
293 case VendorDeviceOutRequest
| FTDI_SET_MDM_CTRL
:
296 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
);
297 if (value
& FTDI_SET_RTS
) {
298 if (value
& FTDI_RTS
) {
299 flags
|= CHR_TIOCM_RTS
;
301 flags
&= ~CHR_TIOCM_RTS
;
304 if (value
& FTDI_SET_DTR
) {
305 if (value
& FTDI_DTR
) {
306 flags
|= CHR_TIOCM_DTR
;
308 flags
&= ~CHR_TIOCM_DTR
;
311 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_TIOCM
, &flags
);
314 case VendorDeviceOutRequest
| FTDI_SET_FLOW_CTRL
: {
315 uint8_t flow_control
= index
>> 8;
317 usb_serial_set_flow_control(s
, flow_control
);
318 if (flow_control
& FTDI_XON_XOFF_HS
) {
319 usb_serial_set_xonxoff(s
, value
);
323 case VendorDeviceOutRequest
| FTDI_SET_BAUD
: {
324 static const int subdivisors8
[8] = { 0, 4, 2, 1, 3, 5, 6, 7 };
325 int subdivisor8
= subdivisors8
[((value
& 0xc000) >> 14)
326 | ((index
& 1) << 2)];
327 int divisor
= value
& 0x3fff;
329 /* chip special cases */
330 if (divisor
== 1 && subdivisor8
== 0) {
333 if (divisor
== 0 && subdivisor8
== 0) {
337 s
->params
.speed
= (48000000 / 2) / (8 * divisor
+ subdivisor8
);
338 trace_usb_serial_set_baud(bus
->busnr
, dev
->addr
, s
->params
.speed
);
339 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
342 case VendorDeviceOutRequest
| FTDI_SET_DATA
:
343 switch (value
& 0xff) {
345 s
->params
.data_bits
= 7;
348 s
->params
.data_bits
= 8;
352 * According to a comment in Linux's ftdi_sio.c original FTDI
353 * chips fall back to 8 data bits for unsupported data_bits
355 trace_usb_serial_unsupported_data_bits(bus
->busnr
, dev
->addr
,
357 s
->params
.data_bits
= 8;
360 switch (value
& FTDI_PARITY
) {
362 s
->params
.parity
= 'N';
365 s
->params
.parity
= 'O';
368 s
->params
.parity
= 'E';
371 trace_usb_serial_unsupported_parity(bus
->busnr
, dev
->addr
,
372 value
& FTDI_PARITY
);
376 switch (value
& FTDI_STOP
) {
378 s
->params
.stop_bits
= 1;
381 s
->params
.stop_bits
= 2;
384 trace_usb_serial_unsupported_stopbits(bus
->busnr
, dev
->addr
,
389 trace_usb_serial_set_data(bus
->busnr
, dev
->addr
, s
->params
.parity
,
390 s
->params
.data_bits
, s
->params
.stop_bits
);
391 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
392 /* TODO: TX ON/OFF */
394 case VendorDeviceRequest
| FTDI_GET_MDM_ST
:
395 data
[0] = usb_get_modem_lines(s
) | 1;
396 data
[1] = FTDI_THRE
| FTDI_TEMT
;
397 p
->actual_length
= 2;
399 case VendorDeviceOutRequest
| FTDI_SET_EVENT_CHR
:
400 /* TODO: handle it */
401 s
->event_chr
= value
;
403 case VendorDeviceOutRequest
| FTDI_SET_ERROR_CHR
:
404 /* TODO: handle it */
405 s
->error_chr
= value
;
407 case VendorDeviceOutRequest
| FTDI_SET_LATENCY
:
410 case VendorDeviceRequest
| FTDI_GET_LATENCY
:
411 data
[0] = s
->latency
;
412 p
->actual_length
= 1;
416 trace_usb_serial_unsupported_control(bus
->busnr
, dev
->addr
, request
,
418 p
->status
= USB_RET_STALL
;
423 static void usb_serial_token_in(USBSerialState
*s
, USBPacket
*p
)
425 const int max_packet_size
= desc_iface0
.eps
[0].wMaxPacketSize
;
429 packet_len
= p
->iov
.size
;
430 if (packet_len
<= 2) {
431 p
->status
= USB_RET_NAK
;
435 header
[0] = usb_get_modem_lines(s
) | 1;
436 /* We do not have the uart details */
437 /* handle serial break */
438 if (s
->event_trigger
&& s
->event_trigger
& FTDI_BI
) {
439 s
->event_trigger
&= ~FTDI_BI
;
441 usb_packet_copy(p
, header
, 2);
448 p
->status
= USB_RET_NAK
;
452 while (s
->recv_used
&& packet_len
> 2) {
455 len
= MIN(packet_len
, max_packet_size
);
457 if (len
> s
->recv_used
) {
461 first_len
= RECV_BUF
- s
->recv_ptr
;
462 if (first_len
> len
) {
465 usb_packet_copy(p
, header
, 2);
466 usb_packet_copy(p
, s
->recv_buf
+ s
->recv_ptr
, first_len
);
467 if (len
> first_len
) {
468 usb_packet_copy(p
, s
->recv_buf
, len
- first_len
);
471 s
->recv_ptr
= (s
->recv_ptr
+ len
) % RECV_BUF
;
472 packet_len
-= len
+ 2;
478 static void usb_serial_handle_data(USBDevice
*dev
, USBPacket
*p
)
480 USBSerialState
*s
= USB_SERIAL(dev
);
481 USBBus
*bus
= usb_bus_from_device(dev
);
482 uint8_t devep
= p
->ep
->nr
;
491 for (i
= 0; i
< p
->iov
.niov
; i
++) {
492 iov
= p
->iov
.iov
+ i
;
494 * XXX this blocks entire thread. Rewrite to use
495 * qemu_chr_fe_write and background I/O callbacks
497 qemu_chr_fe_write_all(&s
->cs
, iov
->iov_base
, iov
->iov_len
);
499 p
->actual_length
= p
->iov
.size
;
506 usb_serial_token_in(s
, p
);
510 trace_usb_serial_bad_token(bus
->busnr
, dev
->addr
);
512 p
->status
= USB_RET_STALL
;
517 static int usb_serial_can_read(void *opaque
)
519 USBSerialState
*s
= opaque
;
521 if (!s
->dev
.attached
) {
524 return RECV_BUF
- s
->recv_used
;
527 static void usb_serial_read(void *opaque
, const uint8_t *buf
, int size
)
529 USBSerialState
*s
= opaque
;
530 int first_size
, start
;
532 /* room in the buffer? */
533 if (size
> (RECV_BUF
- s
->recv_used
)) {
534 size
= RECV_BUF
- s
->recv_used
;
537 start
= s
->recv_ptr
+ s
->recv_used
;
538 if (start
< RECV_BUF
) {
539 /* copy data to end of buffer */
540 first_size
= RECV_BUF
- start
;
541 if (first_size
> size
) {
545 memcpy(s
->recv_buf
+ start
, buf
, first_size
);
547 /* wrap around to front if needed */
548 if (size
> first_size
) {
549 memcpy(s
->recv_buf
, buf
+ first_size
, size
- first_size
);
553 memcpy(s
->recv_buf
+ start
, buf
, size
);
555 s
->recv_used
+= size
;
557 usb_wakeup(s
->intr
, 0);
560 static void usb_serial_event(void *opaque
, QEMUChrEvent event
)
562 USBSerialState
*s
= opaque
;
565 case CHR_EVENT_BREAK
:
566 s
->event_trigger
|= FTDI_BI
;
568 case CHR_EVENT_OPENED
:
569 if (!s
->always_plugged
&& !s
->dev
.attached
) {
570 usb_device_attach(&s
->dev
, &error_abort
);
573 case CHR_EVENT_CLOSED
:
574 if (!s
->always_plugged
&& s
->dev
.attached
) {
575 usb_device_detach(&s
->dev
);
578 case CHR_EVENT_MUX_IN
:
579 case CHR_EVENT_MUX_OUT
:
585 static void usb_serial_realize(USBDevice
*dev
, Error
**errp
)
587 USBSerialState
*s
= USB_SERIAL(dev
);
588 Error
*local_err
= NULL
;
590 usb_desc_create_serial(dev
);
592 dev
->auto_attach
= 0;
594 if (!qemu_chr_fe_backend_connected(&s
->cs
)) {
595 error_setg(errp
, "Property chardev is required");
599 usb_check_attach(dev
, &local_err
);
601 error_propagate(errp
, local_err
);
605 qemu_chr_fe_set_handlers(&s
->cs
, usb_serial_can_read
, usb_serial_read
,
606 usb_serial_event
, NULL
, s
, NULL
, true);
607 usb_serial_handle_reset(dev
);
609 if ((s
->always_plugged
|| qemu_chr_fe_backend_open(&s
->cs
)) &&
611 usb_device_attach(dev
, &error_abort
);
613 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, 1);
616 static USBDevice
*usb_braille_init(const char *unused
)
621 cdrv
= qemu_chr_new("braille", "braille", NULL
);
626 dev
= usb_new("usb-braille");
627 qdev_prop_set_chr(&dev
->qdev
, "chardev", cdrv
);
631 static const VMStateDescription vmstate_usb_serial
= {
632 .name
= "usb-serial",
636 static Property serial_properties
[] = {
637 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
638 DEFINE_PROP_BOOL("always-plugged", USBSerialState
, always_plugged
, false),
639 DEFINE_PROP_END_OF_LIST(),
642 static void usb_serial_dev_class_init(ObjectClass
*klass
, void *data
)
644 DeviceClass
*dc
= DEVICE_CLASS(klass
);
645 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
647 uc
->realize
= usb_serial_realize
;
648 uc
->handle_reset
= usb_serial_handle_reset
;
649 uc
->handle_control
= usb_serial_handle_control
;
650 uc
->handle_data
= usb_serial_handle_data
;
651 dc
->vmsd
= &vmstate_usb_serial
;
652 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
655 static const TypeInfo usb_serial_dev_type_info
= {
656 .name
= TYPE_USB_SERIAL
,
657 .parent
= TYPE_USB_DEVICE
,
658 .instance_size
= sizeof(USBSerialState
),
660 .class_init
= usb_serial_dev_class_init
,
663 static void usb_serial_class_initfn(ObjectClass
*klass
, void *data
)
665 DeviceClass
*dc
= DEVICE_CLASS(klass
);
666 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
668 uc
->product_desc
= "QEMU USB Serial";
669 uc
->usb_desc
= &desc_serial
;
670 device_class_set_props(dc
, serial_properties
);
673 static const TypeInfo serial_info
= {
674 .name
= "usb-serial",
675 .parent
= TYPE_USB_SERIAL
,
676 .class_init
= usb_serial_class_initfn
,
679 static Property braille_properties
[] = {
680 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
681 DEFINE_PROP_END_OF_LIST(),
684 static void usb_braille_class_initfn(ObjectClass
*klass
, void *data
)
686 DeviceClass
*dc
= DEVICE_CLASS(klass
);
687 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
689 uc
->product_desc
= "QEMU USB Braille";
690 uc
->usb_desc
= &desc_braille
;
691 device_class_set_props(dc
, braille_properties
);
694 static const TypeInfo braille_info
= {
695 .name
= "usb-braille",
696 .parent
= TYPE_USB_SERIAL
,
697 .class_init
= usb_braille_class_initfn
,
700 static void usb_serial_register_types(void)
702 type_register_static(&usb_serial_dev_type_info
);
703 type_register_static(&serial_info
);
704 type_register_static(&braille_info
);
705 usb_legacy_register("usb-braille", "braille", usb_braille_init
);
708 type_init(usb_serial_register_types
)