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"
24 //#define DEBUG_Serial
27 #define DPRINTF(fmt, ...) \
28 do { printf("usb-serial: " fmt , ## __VA_ARGS__); } while (0)
30 #define DPRINTF(fmt, ...) do {} while(0)
33 #define RECV_BUF (512 - (2 * 8))
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
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)
52 #define FTDI_RESET_SIO 0
53 #define FTDI_RESET_RX 1
54 #define FTDI_RESET_TX 2
59 #define FTDI_SET_DTR (FTDI_DTR << 8)
61 #define FTDI_SET_RTS (FTDI_RTS << 8)
65 #define FTDI_RTS_CTS_HS 1
66 #define FTDI_DTR_DSR_HS 2
67 #define FTDI_XON_XOFF_HS 4
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)
77 #define FTDI_STOP (0x3 << 11)
78 #define FTDI_STOP1 (0x0 << 11)
79 #define FTDI_STOP15 (0x1 << 11)
80 #define FTDI_STOP2 (0x2 << 11)
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
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
100 struct USBSerialState
{
103 uint8_t recv_buf
[RECV_BUF
];
108 uint8_t event_trigger
;
109 QEMUSerialSetParams params
;
110 int latency
; /* ms */
113 typedef struct USBSerialState USBSerialState
;
115 #define TYPE_USB_SERIAL "usb-serial-dev"
116 DECLARE_INSTANCE_CHECKER(USBSerialState
, USB_SERIAL
,
120 STR_MANUFACTURER
= 1,
126 static const USBDescStrings desc_strings
= {
127 [STR_MANUFACTURER
] = "QEMU",
128 [STR_PRODUCT_SERIAL
] = "QEMU USB SERIAL",
129 [STR_PRODUCT_BRAILLE
] = "QEMU USB BAUM BRAILLE",
130 [STR_SERIALNUMBER
] = "1",
133 static const USBDescIface desc_iface0
= {
134 .bInterfaceNumber
= 0,
136 .bInterfaceClass
= 0xff,
137 .bInterfaceSubClass
= 0xff,
138 .bInterfaceProtocol
= 0xff,
139 .eps
= (USBDescEndpoint
[]) {
141 .bEndpointAddress
= USB_DIR_IN
| 0x01,
142 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
143 .wMaxPacketSize
= 64,
145 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
146 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
147 .wMaxPacketSize
= 64,
152 static const USBDescDevice desc_device
= {
154 .bMaxPacketSize0
= 8,
155 .bNumConfigurations
= 1,
156 .confs
= (USBDescConfig
[]) {
159 .bConfigurationValue
= 1,
160 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_WAKEUP
,
168 static const USBDesc desc_serial
= {
173 .iManufacturer
= STR_MANUFACTURER
,
174 .iProduct
= STR_PRODUCT_SERIAL
,
175 .iSerialNumber
= STR_SERIALNUMBER
,
177 .full
= &desc_device
,
181 static const USBDesc desc_braille
= {
186 .iManufacturer
= STR_MANUFACTURER
,
187 .iProduct
= STR_PRODUCT_BRAILLE
,
188 .iSerialNumber
= STR_SERIALNUMBER
,
190 .full
= &desc_device
,
194 static void usb_serial_reset(USBSerialState
*s
)
196 /* TODO: Set flow control to none */
198 s
->event_trigger
= 0;
201 /* TODO: purge in char driver */
204 static void usb_serial_handle_reset(USBDevice
*dev
)
206 USBSerialState
*s
= (USBSerialState
*)dev
;
211 /* TODO: Reset char device, send BREAK? */
214 static uint8_t usb_get_modem_lines(USBSerialState
*s
)
219 if (qemu_chr_fe_ioctl(&s
->cs
,
220 CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
) == -ENOTSUP
) {
221 return FTDI_CTS
|FTDI_DSR
|FTDI_RLSD
;
225 if (flags
& CHR_TIOCM_CTS
)
227 if (flags
& CHR_TIOCM_DSR
)
229 if (flags
& CHR_TIOCM_RI
)
231 if (flags
& CHR_TIOCM_CAR
)
237 static void usb_serial_handle_control(USBDevice
*dev
, USBPacket
*p
,
238 int request
, int value
, int index
, int length
, uint8_t *data
)
240 USBSerialState
*s
= (USBSerialState
*)dev
;
243 DPRINTF("got control %x, value %x\n",request
, value
);
244 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
250 case EndpointOutRequest
| USB_REQ_CLEAR_FEATURE
:
253 /* Class specific requests. */
254 case DeviceOutVendor
| FTDI_RESET
:
262 /* TODO: purge from char device */
265 /* TODO: purge from char device */
269 case DeviceOutVendor
| FTDI_SET_MDM_CTRL
:
272 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
);
273 if (value
& FTDI_SET_RTS
) {
274 if (value
& FTDI_RTS
)
275 flags
|= CHR_TIOCM_RTS
;
277 flags
&= ~CHR_TIOCM_RTS
;
279 if (value
& FTDI_SET_DTR
) {
280 if (value
& FTDI_DTR
)
281 flags
|= CHR_TIOCM_DTR
;
283 flags
&= ~CHR_TIOCM_DTR
;
285 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_TIOCM
, &flags
);
288 case DeviceOutVendor
| FTDI_SET_FLOW_CTRL
:
291 case DeviceOutVendor
| FTDI_SET_BAUD
: {
292 static const int subdivisors8
[8] = { 0, 4, 2, 1, 3, 5, 6, 7 };
293 int subdivisor8
= subdivisors8
[((value
& 0xc000) >> 14)
294 | ((index
& 1) << 2)];
295 int divisor
= value
& 0x3fff;
297 /* chip special cases */
298 if (divisor
== 1 && subdivisor8
== 0)
300 if (divisor
== 0 && subdivisor8
== 0)
303 s
->params
.speed
= (48000000 / 2) / (8 * divisor
+ subdivisor8
);
304 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
307 case DeviceOutVendor
| FTDI_SET_DATA
:
308 switch (value
& FTDI_PARITY
) {
310 s
->params
.parity
= 'N';
313 s
->params
.parity
= 'O';
316 s
->params
.parity
= 'E';
319 DPRINTF("unsupported parity %d\n", value
& FTDI_PARITY
);
322 switch (value
& FTDI_STOP
) {
324 s
->params
.stop_bits
= 1;
327 s
->params
.stop_bits
= 2;
330 DPRINTF("unsupported stop bits %d\n", value
& FTDI_STOP
);
333 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
334 /* TODO: TX ON/OFF */
336 case DeviceInVendor
| FTDI_GET_MDM_ST
:
337 data
[0] = usb_get_modem_lines(s
) | 1;
338 data
[1] = FTDI_THRE
| FTDI_TEMT
;
339 p
->actual_length
= 2;
341 case DeviceOutVendor
| FTDI_SET_EVENT_CHR
:
342 /* TODO: handle it */
343 s
->event_chr
= value
;
345 case DeviceOutVendor
| FTDI_SET_ERROR_CHR
:
346 /* TODO: handle it */
347 s
->error_chr
= value
;
349 case DeviceOutVendor
| FTDI_SET_LATENCY
:
352 case DeviceInVendor
| FTDI_GET_LATENCY
:
353 data
[0] = s
->latency
;
354 p
->actual_length
= 1;
358 DPRINTF("got unsupported/bogus control %x, value %x\n", request
, value
);
359 p
->status
= USB_RET_STALL
;
364 static void usb_serial_token_in(USBSerialState
*s
, USBPacket
*p
)
366 const int max_packet_size
= desc_iface0
.eps
[0].wMaxPacketSize
;
370 packet_len
= p
->iov
.size
;
371 if (packet_len
<= 2) {
372 p
->status
= USB_RET_NAK
;
376 header
[0] = usb_get_modem_lines(s
) | 1;
377 /* We do not have the uart details */
378 /* handle serial break */
379 if (s
->event_trigger
&& s
->event_trigger
& FTDI_BI
) {
380 s
->event_trigger
&= ~FTDI_BI
;
382 usb_packet_copy(p
, header
, 2);
389 p
->status
= USB_RET_NAK
;
393 while (s
->recv_used
&& packet_len
> 2) {
396 len
= MIN(packet_len
, max_packet_size
);
398 if (len
> s
->recv_used
) {
402 first_len
= RECV_BUF
- s
->recv_ptr
;
403 if (first_len
> len
) {
406 usb_packet_copy(p
, header
, 2);
407 usb_packet_copy(p
, s
->recv_buf
+ s
->recv_ptr
, first_len
);
408 if (len
> first_len
) {
409 usb_packet_copy(p
, s
->recv_buf
, len
- first_len
);
412 s
->recv_ptr
= (s
->recv_ptr
+ len
) % RECV_BUF
;
413 packet_len
-= len
+ 2;
419 static void usb_serial_handle_data(USBDevice
*dev
, USBPacket
*p
)
421 USBSerialState
*s
= (USBSerialState
*)dev
;
422 uint8_t devep
= p
->ep
->nr
;
430 for (i
= 0; i
< p
->iov
.niov
; i
++) {
431 iov
= p
->iov
.iov
+ i
;
432 /* XXX this blocks entire thread. Rewrite to use
433 * qemu_chr_fe_write and background I/O callbacks */
434 qemu_chr_fe_write_all(&s
->cs
, iov
->iov_base
, iov
->iov_len
);
436 p
->actual_length
= p
->iov
.size
;
442 usb_serial_token_in(s
, p
);
446 DPRINTF("Bad token\n");
448 p
->status
= USB_RET_STALL
;
453 static int usb_serial_can_read(void *opaque
)
455 USBSerialState
*s
= opaque
;
457 if (!s
->dev
.attached
) {
460 return RECV_BUF
- s
->recv_used
;
463 static void usb_serial_read(void *opaque
, const uint8_t *buf
, int size
)
465 USBSerialState
*s
= opaque
;
466 int first_size
, start
;
468 /* room in the buffer? */
469 if (size
> (RECV_BUF
- s
->recv_used
))
470 size
= RECV_BUF
- s
->recv_used
;
472 start
= s
->recv_ptr
+ s
->recv_used
;
473 if (start
< RECV_BUF
) {
474 /* copy data to end of buffer */
475 first_size
= RECV_BUF
- start
;
476 if (first_size
> size
)
479 memcpy(s
->recv_buf
+ start
, buf
, first_size
);
481 /* wrap around to front if needed */
482 if (size
> first_size
)
483 memcpy(s
->recv_buf
, buf
+ first_size
, size
- first_size
);
486 memcpy(s
->recv_buf
+ start
, buf
, size
);
488 s
->recv_used
+= size
;
490 usb_wakeup(s
->intr
, 0);
493 static void usb_serial_event(void *opaque
, QEMUChrEvent event
)
495 USBSerialState
*s
= opaque
;
498 case CHR_EVENT_BREAK
:
499 s
->event_trigger
|= FTDI_BI
;
501 case CHR_EVENT_OPENED
:
502 if (!s
->dev
.attached
) {
503 usb_device_attach(&s
->dev
, &error_abort
);
506 case CHR_EVENT_CLOSED
:
507 if (s
->dev
.attached
) {
508 usb_device_detach(&s
->dev
);
511 case CHR_EVENT_MUX_IN
:
512 case CHR_EVENT_MUX_OUT
:
518 static void usb_serial_realize(USBDevice
*dev
, Error
**errp
)
520 USBSerialState
*s
= USB_SERIAL(dev
);
521 Error
*local_err
= NULL
;
523 usb_desc_create_serial(dev
);
525 dev
->auto_attach
= 0;
527 if (!qemu_chr_fe_backend_connected(&s
->cs
)) {
528 error_setg(errp
, "Property chardev is required");
532 usb_check_attach(dev
, &local_err
);
534 error_propagate(errp
, local_err
);
538 qemu_chr_fe_set_handlers(&s
->cs
, usb_serial_can_read
, usb_serial_read
,
539 usb_serial_event
, NULL
, s
, NULL
, true);
540 usb_serial_handle_reset(dev
);
542 if (qemu_chr_fe_backend_open(&s
->cs
) && !dev
->attached
) {
543 usb_device_attach(dev
, &error_abort
);
545 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, 1);
548 static USBDevice
*usb_braille_init(const char *unused
)
553 cdrv
= qemu_chr_new("braille", "braille", NULL
);
557 dev
= usb_new("usb-braille");
558 qdev_prop_set_chr(&dev
->qdev
, "chardev", cdrv
);
562 static const VMStateDescription vmstate_usb_serial
= {
563 .name
= "usb-serial",
567 static Property serial_properties
[] = {
568 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
569 DEFINE_PROP_END_OF_LIST(),
572 static void usb_serial_dev_class_init(ObjectClass
*klass
, void *data
)
574 DeviceClass
*dc
= DEVICE_CLASS(klass
);
575 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
577 uc
->realize
= usb_serial_realize
;
578 uc
->handle_reset
= usb_serial_handle_reset
;
579 uc
->handle_control
= usb_serial_handle_control
;
580 uc
->handle_data
= usb_serial_handle_data
;
581 dc
->vmsd
= &vmstate_usb_serial
;
582 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
585 static const TypeInfo usb_serial_dev_type_info
= {
586 .name
= TYPE_USB_SERIAL
,
587 .parent
= TYPE_USB_DEVICE
,
588 .instance_size
= sizeof(USBSerialState
),
590 .class_init
= usb_serial_dev_class_init
,
593 static void usb_serial_class_initfn(ObjectClass
*klass
, void *data
)
595 DeviceClass
*dc
= DEVICE_CLASS(klass
);
596 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
598 uc
->product_desc
= "QEMU USB Serial";
599 uc
->usb_desc
= &desc_serial
;
600 device_class_set_props(dc
, serial_properties
);
603 static const TypeInfo serial_info
= {
604 .name
= "usb-serial",
605 .parent
= TYPE_USB_SERIAL
,
606 .class_init
= usb_serial_class_initfn
,
609 static Property braille_properties
[] = {
610 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
611 DEFINE_PROP_END_OF_LIST(),
614 static void usb_braille_class_initfn(ObjectClass
*klass
, void *data
)
616 DeviceClass
*dc
= DEVICE_CLASS(klass
);
617 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
619 uc
->product_desc
= "QEMU USB Braille";
620 uc
->usb_desc
= &desc_braille
;
621 device_class_set_props(dc
, braille_properties
);
624 static const TypeInfo braille_info
= {
625 .name
= "usb-braille",
626 .parent
= TYPE_USB_SERIAL
,
627 .class_init
= usb_braille_class_initfn
,
630 static void usb_serial_register_types(void)
632 type_register_static(&usb_serial_dev_type_info
);
633 type_register_static(&serial_info
);
634 type_register_static(&braille_info
);
635 usb_legacy_register("usb-braille", "braille", usb_braille_init
);
638 type_init(usb_serial_register_types
)