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"
17 #include "migration/vmstate.h"
19 #include "chardev/char-serial.h"
20 #include "chardev/char-fe.h"
22 //#define DEBUG_Serial
25 #define DPRINTF(fmt, ...) \
26 do { printf("usb-serial: " fmt , ## __VA_ARGS__); } while (0)
28 #define DPRINTF(fmt, ...) do {} while(0)
35 #define FTDI_SET_MDM_CTRL 1
36 #define FTDI_SET_FLOW_CTRL 2
37 #define FTDI_SET_BAUD 3
38 #define FTDI_SET_DATA 4
39 #define FTDI_GET_MDM_ST 5
40 #define FTDI_SET_EVENT_CHR 6
41 #define FTDI_SET_ERROR_CHR 7
42 #define FTDI_SET_LATENCY 9
43 #define FTDI_GET_LATENCY 10
45 #define DeviceOutVendor ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
46 #define DeviceInVendor ((USB_DIR_IN |USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
50 #define FTDI_RESET_SIO 0
51 #define FTDI_RESET_RX 1
52 #define FTDI_RESET_TX 2
57 #define FTDI_SET_DTR (FTDI_DTR << 8)
59 #define FTDI_SET_RTS (FTDI_RTS << 8)
63 #define FTDI_RTS_CTS_HS 1
64 #define FTDI_DTR_DSR_HS 2
65 #define FTDI_XON_XOFF_HS 4
69 #define FTDI_PARITY (0x7 << 8)
70 #define FTDI_ODD (0x1 << 8)
71 #define FTDI_EVEN (0x2 << 8)
72 #define FTDI_MARK (0x3 << 8)
73 #define FTDI_SPACE (0x4 << 8)
75 #define FTDI_STOP (0x3 << 11)
76 #define FTDI_STOP1 (0x0 << 11)
77 #define FTDI_STOP15 (0x1 << 11)
78 #define FTDI_STOP2 (0x2 << 11)
81 /* TODO: should be sent every 40ms */
82 #define FTDI_CTS (1<<4) // CTS line status
83 #define FTDI_DSR (1<<5) // DSR line status
84 #define FTDI_RI (1<<6) // RI line status
85 #define FTDI_RLSD (1<<7) // Receive Line Signal Detect
89 #define FTDI_DR (1<<0) // Data Ready
90 #define FTDI_OE (1<<1) // Overrun Err
91 #define FTDI_PE (1<<2) // Parity Err
92 #define FTDI_FE (1<<3) // Framing Err
93 #define FTDI_BI (1<<4) // Break Interrupt
94 #define FTDI_THRE (1<<5) // Transmitter Holding Register
95 #define FTDI_TEMT (1<<6) // Transmitter Empty
96 #define FTDI_FIFO (1<<7) // Error in FIFO
100 uint8_t recv_buf
[RECV_BUF
];
105 uint8_t event_trigger
;
106 QEMUSerialSetParams params
;
107 int latency
; /* ms */
111 #define TYPE_USB_SERIAL "usb-serial-dev"
112 #define USB_SERIAL_DEV(obj) OBJECT_CHECK(USBSerialState, (obj), TYPE_USB_SERIAL)
115 STR_MANUFACTURER
= 1,
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",
128 static const USBDescIface desc_iface0
= {
129 .bInterfaceNumber
= 0,
131 .bInterfaceClass
= 0xff,
132 .bInterfaceSubClass
= 0xff,
133 .bInterfaceProtocol
= 0xff,
134 .eps
= (USBDescEndpoint
[]) {
136 .bEndpointAddress
= USB_DIR_IN
| 0x01,
137 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
138 .wMaxPacketSize
= 64,
140 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
141 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
142 .wMaxPacketSize
= 64,
147 static const USBDescDevice desc_device
= {
149 .bMaxPacketSize0
= 8,
150 .bNumConfigurations
= 1,
151 .confs
= (USBDescConfig
[]) {
154 .bConfigurationValue
= 1,
155 .bmAttributes
= USB_CFG_ATT_ONE
,
163 static const USBDesc desc_serial
= {
168 .iManufacturer
= STR_MANUFACTURER
,
169 .iProduct
= STR_PRODUCT_SERIAL
,
170 .iSerialNumber
= STR_SERIALNUMBER
,
172 .full
= &desc_device
,
176 static const USBDesc desc_braille
= {
181 .iManufacturer
= STR_MANUFACTURER
,
182 .iProduct
= STR_PRODUCT_BRAILLE
,
183 .iSerialNumber
= STR_SERIALNUMBER
,
185 .full
= &desc_device
,
189 static void usb_serial_reset(USBSerialState
*s
)
191 /* TODO: Set flow control to none */
193 s
->event_trigger
= 0;
196 /* TODO: purge in char driver */
199 static void usb_serial_handle_reset(USBDevice
*dev
)
201 USBSerialState
*s
= (USBSerialState
*)dev
;
206 /* TODO: Reset char device, send BREAK? */
209 static uint8_t usb_get_modem_lines(USBSerialState
*s
)
214 if (qemu_chr_fe_ioctl(&s
->cs
,
215 CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
) == -ENOTSUP
) {
216 return FTDI_CTS
|FTDI_DSR
|FTDI_RLSD
;
220 if (flags
& CHR_TIOCM_CTS
)
222 if (flags
& CHR_TIOCM_DSR
)
224 if (flags
& CHR_TIOCM_RI
)
226 if (flags
& CHR_TIOCM_CAR
)
232 static void usb_serial_handle_control(USBDevice
*dev
, USBPacket
*p
,
233 int request
, int value
, int index
, int length
, uint8_t *data
)
235 USBSerialState
*s
= (USBSerialState
*)dev
;
238 DPRINTF("got control %x, value %x\n",request
, value
);
239 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
245 case EndpointOutRequest
| USB_REQ_CLEAR_FEATURE
:
248 /* Class specific requests. */
249 case DeviceOutVendor
| FTDI_RESET
:
257 /* TODO: purge from char device */
260 /* TODO: purge from char device */
264 case DeviceOutVendor
| FTDI_SET_MDM_CTRL
:
267 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_GET_TIOCM
, &flags
);
268 if (value
& FTDI_SET_RTS
) {
269 if (value
& FTDI_RTS
)
270 flags
|= CHR_TIOCM_RTS
;
272 flags
&= ~CHR_TIOCM_RTS
;
274 if (value
& FTDI_SET_DTR
) {
275 if (value
& FTDI_DTR
)
276 flags
|= CHR_TIOCM_DTR
;
278 flags
&= ~CHR_TIOCM_DTR
;
280 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_TIOCM
, &flags
);
283 case DeviceOutVendor
| FTDI_SET_FLOW_CTRL
:
286 case DeviceOutVendor
| FTDI_SET_BAUD
: {
287 static const int subdivisors8
[8] = { 0, 4, 2, 1, 3, 5, 6, 7 };
288 int subdivisor8
= subdivisors8
[((value
& 0xc000) >> 14)
289 | ((index
& 1) << 2)];
290 int divisor
= value
& 0x3fff;
292 /* chip special cases */
293 if (divisor
== 1 && subdivisor8
== 0)
295 if (divisor
== 0 && subdivisor8
== 0)
298 s
->params
.speed
= (48000000 / 2) / (8 * divisor
+ subdivisor8
);
299 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
302 case DeviceOutVendor
| FTDI_SET_DATA
:
303 switch (value
& FTDI_PARITY
) {
305 s
->params
.parity
= 'N';
308 s
->params
.parity
= 'O';
311 s
->params
.parity
= 'E';
314 DPRINTF("unsupported parity %d\n", value
& FTDI_PARITY
);
317 switch (value
& FTDI_STOP
) {
319 s
->params
.stop_bits
= 1;
322 s
->params
.stop_bits
= 2;
325 DPRINTF("unsupported stop bits %d\n", value
& FTDI_STOP
);
328 qemu_chr_fe_ioctl(&s
->cs
, CHR_IOCTL_SERIAL_SET_PARAMS
, &s
->params
);
329 /* TODO: TX ON/OFF */
331 case DeviceInVendor
| FTDI_GET_MDM_ST
:
332 data
[0] = usb_get_modem_lines(s
) | 1;
334 p
->actual_length
= 2;
336 case DeviceOutVendor
| FTDI_SET_EVENT_CHR
:
337 /* TODO: handle it */
338 s
->event_chr
= value
;
340 case DeviceOutVendor
| FTDI_SET_ERROR_CHR
:
341 /* TODO: handle it */
342 s
->error_chr
= value
;
344 case DeviceOutVendor
| FTDI_SET_LATENCY
:
347 case DeviceInVendor
| FTDI_GET_LATENCY
:
348 data
[0] = s
->latency
;
349 p
->actual_length
= 1;
353 DPRINTF("got unsupported/bogus control %x, value %x\n", request
, value
);
354 p
->status
= USB_RET_STALL
;
359 static void usb_serial_handle_data(USBDevice
*dev
, USBPacket
*p
)
361 USBSerialState
*s
= (USBSerialState
*)dev
;
362 uint8_t devep
= p
->ep
->nr
;
365 int i
, first_len
, len
;
371 for (i
= 0; i
< p
->iov
.niov
; i
++) {
372 iov
= p
->iov
.iov
+ i
;
373 /* XXX this blocks entire thread. Rewrite to use
374 * qemu_chr_fe_write and background I/O callbacks */
375 qemu_chr_fe_write_all(&s
->cs
, iov
->iov_base
, iov
->iov_len
);
377 p
->actual_length
= p
->iov
.size
;
383 first_len
= RECV_BUF
- s
->recv_ptr
;
386 p
->status
= USB_RET_NAK
;
389 header
[0] = usb_get_modem_lines(s
) | 1;
390 /* We do not have the uart details */
391 /* handle serial break */
392 if (s
->event_trigger
&& s
->event_trigger
& FTDI_BI
) {
393 s
->event_trigger
&= ~FTDI_BI
;
395 usb_packet_copy(p
, header
, 2);
401 if (len
> s
->recv_used
)
404 p
->status
= USB_RET_NAK
;
409 usb_packet_copy(p
, header
, 2);
410 usb_packet_copy(p
, s
->recv_buf
+ s
->recv_ptr
, first_len
);
412 usb_packet_copy(p
, s
->recv_buf
, len
- first_len
);
414 s
->recv_ptr
= (s
->recv_ptr
+ len
) % RECV_BUF
;
418 DPRINTF("Bad token\n");
420 p
->status
= USB_RET_STALL
;
425 static int usb_serial_can_read(void *opaque
)
427 USBSerialState
*s
= opaque
;
429 if (!s
->dev
.attached
) {
432 return RECV_BUF
- s
->recv_used
;
435 static void usb_serial_read(void *opaque
, const uint8_t *buf
, int size
)
437 USBSerialState
*s
= opaque
;
438 int first_size
, start
;
440 /* room in the buffer? */
441 if (size
> (RECV_BUF
- s
->recv_used
))
442 size
= RECV_BUF
- s
->recv_used
;
444 start
= s
->recv_ptr
+ s
->recv_used
;
445 if (start
< RECV_BUF
) {
446 /* copy data to end of buffer */
447 first_size
= RECV_BUF
- start
;
448 if (first_size
> size
)
451 memcpy(s
->recv_buf
+ start
, buf
, first_size
);
453 /* wrap around to front if needed */
454 if (size
> first_size
)
455 memcpy(s
->recv_buf
, buf
+ first_size
, size
- first_size
);
458 memcpy(s
->recv_buf
+ start
, buf
, size
);
460 s
->recv_used
+= size
;
463 static void usb_serial_event(void *opaque
, int event
)
465 USBSerialState
*s
= opaque
;
468 case CHR_EVENT_BREAK
:
469 s
->event_trigger
|= FTDI_BI
;
471 case CHR_EVENT_OPENED
:
472 if (!s
->dev
.attached
) {
473 usb_device_attach(&s
->dev
, &error_abort
);
476 case CHR_EVENT_CLOSED
:
477 if (s
->dev
.attached
) {
478 usb_device_detach(&s
->dev
);
484 static void usb_serial_realize(USBDevice
*dev
, Error
**errp
)
486 USBSerialState
*s
= USB_SERIAL_DEV(dev
);
487 Error
*local_err
= NULL
;
489 usb_desc_create_serial(dev
);
491 dev
->auto_attach
= 0;
493 if (!qemu_chr_fe_backend_connected(&s
->cs
)) {
494 error_setg(errp
, "Property chardev is required");
498 usb_check_attach(dev
, &local_err
);
500 error_propagate(errp
, local_err
);
504 qemu_chr_fe_set_handlers(&s
->cs
, usb_serial_can_read
, usb_serial_read
,
505 usb_serial_event
, NULL
, s
, NULL
, true);
506 usb_serial_handle_reset(dev
);
508 if (qemu_chr_fe_backend_open(&s
->cs
) && !dev
->attached
) {
509 usb_device_attach(dev
, &error_abort
);
513 static USBDevice
*usb_braille_init(USBBus
*bus
, const char *unused
)
518 cdrv
= qemu_chr_new("braille", "braille", NULL
);
522 dev
= usb_create(bus
, "usb-braille");
523 qdev_prop_set_chr(&dev
->qdev
, "chardev", cdrv
);
527 static const VMStateDescription vmstate_usb_serial
= {
528 .name
= "usb-serial",
532 static Property serial_properties
[] = {
533 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
534 DEFINE_PROP_END_OF_LIST(),
537 static void usb_serial_dev_class_init(ObjectClass
*klass
, void *data
)
539 DeviceClass
*dc
= DEVICE_CLASS(klass
);
540 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
542 uc
->realize
= usb_serial_realize
;
543 uc
->handle_reset
= usb_serial_handle_reset
;
544 uc
->handle_control
= usb_serial_handle_control
;
545 uc
->handle_data
= usb_serial_handle_data
;
546 dc
->vmsd
= &vmstate_usb_serial
;
547 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
550 static const TypeInfo usb_serial_dev_type_info
= {
551 .name
= TYPE_USB_SERIAL
,
552 .parent
= TYPE_USB_DEVICE
,
553 .instance_size
= sizeof(USBSerialState
),
555 .class_init
= usb_serial_dev_class_init
,
558 static void usb_serial_class_initfn(ObjectClass
*klass
, void *data
)
560 DeviceClass
*dc
= DEVICE_CLASS(klass
);
561 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
563 uc
->product_desc
= "QEMU USB Serial";
564 uc
->usb_desc
= &desc_serial
;
565 dc
->props
= serial_properties
;
568 static const TypeInfo serial_info
= {
569 .name
= "usb-serial",
570 .parent
= TYPE_USB_SERIAL
,
571 .class_init
= usb_serial_class_initfn
,
574 static Property braille_properties
[] = {
575 DEFINE_PROP_CHR("chardev", USBSerialState
, cs
),
576 DEFINE_PROP_END_OF_LIST(),
579 static void usb_braille_class_initfn(ObjectClass
*klass
, void *data
)
581 DeviceClass
*dc
= DEVICE_CLASS(klass
);
582 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
584 uc
->product_desc
= "QEMU USB Braille";
585 uc
->usb_desc
= &desc_braille
;
586 dc
->props
= braille_properties
;
589 static const TypeInfo braille_info
= {
590 .name
= "usb-braille",
591 .parent
= TYPE_USB_SERIAL
,
592 .class_init
= usb_braille_class_initfn
,
595 static void usb_serial_register_types(void)
597 type_register_static(&usb_serial_dev_type_info
);
598 type_register_static(&serial_info
);
599 type_register_static(&braille_info
);
600 usb_legacy_register("usb-braille", "braille", usb_braille_init
);
603 type_init(usb_serial_register_types
)