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