]>
Commit | Line | Data |
---|---|---|
a7954218 AZ |
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 | * | |
8e31bf38 | 8 | * This code is licensed under the LGPL. |
a7954218 AZ |
9 | */ |
10 | ||
e532b2e0 | 11 | #include "qemu/osdep.h" |
da34e65c | 12 | #include "qapi/error.h" |
a7954218 | 13 | #include "qemu-common.h" |
f348b6d1 | 14 | #include "qemu/cutils.h" |
d49b6836 | 15 | #include "qemu/error-report.h" |
f1ae32a1 GH |
16 | #include "hw/usb.h" |
17 | #include "hw/usb/desc.h" | |
dccfcd0e | 18 | #include "sysemu/char.h" |
a7954218 AZ |
19 | |
20 | //#define DEBUG_Serial | |
21 | ||
22 | #ifdef DEBUG_Serial | |
001faf32 BS |
23 | #define DPRINTF(fmt, ...) \ |
24 | do { printf("usb-serial: " fmt , ## __VA_ARGS__); } while (0) | |
a7954218 | 25 | #else |
001faf32 | 26 | #define DPRINTF(fmt, ...) do {} while(0) |
a7954218 AZ |
27 | #endif |
28 | ||
29 | #define RECV_BUF 384 | |
a7954218 AZ |
30 | |
31 | /* Commands */ | |
32 | #define FTDI_RESET 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 | |
42 | ||
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) | |
45 | ||
46 | /* RESET */ | |
47 | ||
48 | #define FTDI_RESET_SIO 0 | |
49 | #define FTDI_RESET_RX 1 | |
50 | #define FTDI_RESET_TX 2 | |
51 | ||
52 | /* SET_MDM_CTRL */ | |
53 | ||
a7954218 | 54 | #define FTDI_DTR 1 |
abb8a139 | 55 | #define FTDI_SET_DTR (FTDI_DTR << 8) |
a7954218 | 56 | #define FTDI_RTS 2 |
abb8a139 | 57 | #define FTDI_SET_RTS (FTDI_RTS << 8) |
a7954218 AZ |
58 | |
59 | /* SET_FLOW_CTRL */ | |
60 | ||
61 | #define FTDI_RTS_CTS_HS 1 | |
62 | #define FTDI_DTR_DSR_HS 2 | |
63 | #define FTDI_XON_XOFF_HS 4 | |
64 | ||
65 | /* SET_DATA */ | |
66 | ||
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) | |
72 | ||
73 | #define FTDI_STOP (0x3 << 11) | |
74 | #define FTDI_STOP1 (0x0 << 11) | |
75 | #define FTDI_STOP15 (0x1 << 11) | |
76 | #define FTDI_STOP2 (0x2 << 11) | |
77 | ||
78 | /* GET_MDM_ST */ | |
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 | |
84 | ||
85 | /* Status */ | |
86 | ||
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 | |
95 | ||
96 | typedef struct { | |
97 | USBDevice dev; | |
a7954218 | 98 | uint8_t recv_buf[RECV_BUF]; |
8109b9b6 AJ |
99 | uint16_t recv_ptr; |
100 | uint16_t recv_used; | |
a7954218 AZ |
101 | uint8_t event_chr; |
102 | uint8_t error_chr; | |
103 | uint8_t event_trigger; | |
a7954218 AZ |
104 | QEMUSerialSetParams params; |
105 | int latency; /* ms */ | |
106 | CharDriverState *cs; | |
107 | } USBSerialState; | |
108 | ||
cdf0d769 GA |
109 | #define TYPE_USB_SERIAL "usb-serial-dev" |
110 | #define USB_SERIAL_DEV(obj) OBJECT_CHECK(USBSerialState, (obj), TYPE_USB_SERIAL) | |
111 | ||
f29783f7 GH |
112 | enum { |
113 | STR_MANUFACTURER = 1, | |
114 | STR_PRODUCT_SERIAL, | |
115 | STR_PRODUCT_BRAILLE, | |
116 | STR_SERIALNUMBER, | |
a7954218 AZ |
117 | }; |
118 | ||
f29783f7 | 119 | static const USBDescStrings desc_strings = { |
93bfef4c | 120 | [STR_MANUFACTURER] = "QEMU", |
f29783f7 | 121 | [STR_PRODUCT_SERIAL] = "QEMU USB SERIAL", |
2964cd9b | 122 | [STR_PRODUCT_BRAILLE] = "QEMU USB BAUM BRAILLE", |
f29783f7 GH |
123 | [STR_SERIALNUMBER] = "1", |
124 | }; | |
125 | ||
126 | static const USBDescIface desc_iface0 = { | |
127 | .bInterfaceNumber = 0, | |
128 | .bNumEndpoints = 2, | |
129 | .bInterfaceClass = 0xff, | |
130 | .bInterfaceSubClass = 0xff, | |
131 | .bInterfaceProtocol = 0xff, | |
132 | .eps = (USBDescEndpoint[]) { | |
133 | { | |
134 | .bEndpointAddress = USB_DIR_IN | 0x01, | |
135 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | |
136 | .wMaxPacketSize = 64, | |
137 | },{ | |
138 | .bEndpointAddress = USB_DIR_OUT | 0x02, | |
139 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | |
140 | .wMaxPacketSize = 64, | |
141 | }, | |
142 | } | |
143 | }; | |
144 | ||
145 | static const USBDescDevice desc_device = { | |
146 | .bcdUSB = 0x0200, | |
147 | .bMaxPacketSize0 = 8, | |
148 | .bNumConfigurations = 1, | |
149 | .confs = (USBDescConfig[]) { | |
150 | { | |
151 | .bNumInterfaces = 1, | |
152 | .bConfigurationValue = 1, | |
bd93976a | 153 | .bmAttributes = USB_CFG_ATT_ONE, |
f29783f7 | 154 | .bMaxPower = 50, |
add75088 | 155 | .nif = 1, |
f29783f7 GH |
156 | .ifs = &desc_iface0, |
157 | }, | |
158 | }, | |
159 | }; | |
160 | ||
161 | static const USBDesc desc_serial = { | |
162 | .id = { | |
163 | .idVendor = 0x0403, | |
164 | .idProduct = 0x6001, | |
165 | .bcdDevice = 0x0400, | |
166 | .iManufacturer = STR_MANUFACTURER, | |
167 | .iProduct = STR_PRODUCT_SERIAL, | |
168 | .iSerialNumber = STR_SERIALNUMBER, | |
169 | }, | |
170 | .full = &desc_device, | |
171 | .str = desc_strings, | |
172 | }; | |
173 | ||
174 | static const USBDesc desc_braille = { | |
175 | .id = { | |
176 | .idVendor = 0x0403, | |
177 | .idProduct = 0xfe72, | |
178 | .bcdDevice = 0x0400, | |
179 | .iManufacturer = STR_MANUFACTURER, | |
180 | .iProduct = STR_PRODUCT_BRAILLE, | |
181 | .iSerialNumber = STR_SERIALNUMBER, | |
182 | }, | |
183 | .full = &desc_device, | |
184 | .str = desc_strings, | |
a7954218 AZ |
185 | }; |
186 | ||
187 | static void usb_serial_reset(USBSerialState *s) | |
188 | { | |
189 | /* TODO: Set flow control to none */ | |
190 | s->event_chr = 0x0d; | |
191 | s->event_trigger = 0; | |
192 | s->recv_ptr = 0; | |
193 | s->recv_used = 0; | |
194 | /* TODO: purge in char driver */ | |
a7954218 AZ |
195 | } |
196 | ||
197 | static void usb_serial_handle_reset(USBDevice *dev) | |
198 | { | |
199 | USBSerialState *s = (USBSerialState *)dev; | |
200 | ||
201 | DPRINTF("Reset\n"); | |
202 | ||
203 | usb_serial_reset(s); | |
204 | /* TODO: Reset char device, send BREAK? */ | |
205 | } | |
206 | ||
abb8a139 AJ |
207 | static uint8_t usb_get_modem_lines(USBSerialState *s) |
208 | { | |
209 | int flags; | |
210 | uint8_t ret; | |
211 | ||
41084f1b | 212 | if (qemu_chr_fe_ioctl(s->cs, CHR_IOCTL_SERIAL_GET_TIOCM, &flags) == -ENOTSUP) |
abb8a139 AJ |
213 | return FTDI_CTS|FTDI_DSR|FTDI_RLSD; |
214 | ||
215 | ret = 0; | |
216 | if (flags & CHR_TIOCM_CTS) | |
217 | ret |= FTDI_CTS; | |
218 | if (flags & CHR_TIOCM_DSR) | |
219 | ret |= FTDI_DSR; | |
220 | if (flags & CHR_TIOCM_RI) | |
221 | ret |= FTDI_RI; | |
222 | if (flags & CHR_TIOCM_CAR) | |
223 | ret |= FTDI_RLSD; | |
224 | ||
225 | return ret; | |
226 | } | |
227 | ||
9a77a0f5 | 228 | static void usb_serial_handle_control(USBDevice *dev, USBPacket *p, |
007fd62f | 229 | int request, int value, int index, int length, uint8_t *data) |
a7954218 AZ |
230 | { |
231 | USBSerialState *s = (USBSerialState *)dev; | |
f29783f7 GH |
232 | int ret; |
233 | ||
234 | DPRINTF("got control %x, value %x\n",request, value); | |
007fd62f | 235 | ret = usb_desc_handle_control(dev, p, request, value, index, length, data); |
f29783f7 | 236 | if (ret >= 0) { |
9a77a0f5 | 237 | return; |
f29783f7 | 238 | } |
a7954218 | 239 | |
a7954218 | 240 | switch (request) { |
a7954218 | 241 | case EndpointOutRequest | USB_REQ_CLEAR_FEATURE: |
a7954218 AZ |
242 | break; |
243 | ||
244 | /* Class specific requests. */ | |
245 | case DeviceOutVendor | FTDI_RESET: | |
246 | switch (value) { | |
247 | case FTDI_RESET_SIO: | |
248 | usb_serial_reset(s); | |
249 | break; | |
250 | case FTDI_RESET_RX: | |
251 | s->recv_ptr = 0; | |
252 | s->recv_used = 0; | |
253 | /* TODO: purge from char device */ | |
254 | break; | |
255 | case FTDI_RESET_TX: | |
256 | /* TODO: purge from char device */ | |
257 | break; | |
258 | } | |
259 | break; | |
260 | case DeviceOutVendor | FTDI_SET_MDM_CTRL: | |
abb8a139 AJ |
261 | { |
262 | static int flags; | |
41084f1b | 263 | qemu_chr_fe_ioctl(s->cs,CHR_IOCTL_SERIAL_GET_TIOCM, &flags); |
abb8a139 AJ |
264 | if (value & FTDI_SET_RTS) { |
265 | if (value & FTDI_RTS) | |
266 | flags |= CHR_TIOCM_RTS; | |
267 | else | |
268 | flags &= ~CHR_TIOCM_RTS; | |
269 | } | |
270 | if (value & FTDI_SET_DTR) { | |
271 | if (value & FTDI_DTR) | |
272 | flags |= CHR_TIOCM_DTR; | |
273 | else | |
274 | flags &= ~CHR_TIOCM_DTR; | |
275 | } | |
41084f1b | 276 | qemu_chr_fe_ioctl(s->cs,CHR_IOCTL_SERIAL_SET_TIOCM, &flags); |
a7954218 | 277 | break; |
abb8a139 | 278 | } |
a7954218 AZ |
279 | case DeviceOutVendor | FTDI_SET_FLOW_CTRL: |
280 | /* TODO: ioctl */ | |
281 | break; | |
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; | |
287 | ||
288 | /* chip special cases */ | |
289 | if (divisor == 1 && subdivisor8 == 0) | |
290 | subdivisor8 = 4; | |
291 | if (divisor == 0 && subdivisor8 == 0) | |
292 | divisor = 1; | |
293 | ||
294 | s->params.speed = (48000000 / 2) / (8 * divisor + subdivisor8); | |
41084f1b | 295 | qemu_chr_fe_ioctl(s->cs, CHR_IOCTL_SERIAL_SET_PARAMS, &s->params); |
a7954218 AZ |
296 | break; |
297 | } | |
298 | case DeviceOutVendor | FTDI_SET_DATA: | |
299 | switch (value & FTDI_PARITY) { | |
300 | case 0: | |
301 | s->params.parity = 'N'; | |
302 | break; | |
303 | case FTDI_ODD: | |
304 | s->params.parity = 'O'; | |
305 | break; | |
306 | case FTDI_EVEN: | |
307 | s->params.parity = 'E'; | |
308 | break; | |
309 | default: | |
310 | DPRINTF("unsupported parity %d\n", value & FTDI_PARITY); | |
311 | goto fail; | |
312 | } | |
313 | switch (value & FTDI_STOP) { | |
314 | case FTDI_STOP1: | |
315 | s->params.stop_bits = 1; | |
316 | break; | |
317 | case FTDI_STOP2: | |
318 | s->params.stop_bits = 2; | |
319 | break; | |
320 | default: | |
321 | DPRINTF("unsupported stop bits %d\n", value & FTDI_STOP); | |
322 | goto fail; | |
323 | } | |
41084f1b | 324 | qemu_chr_fe_ioctl(s->cs, CHR_IOCTL_SERIAL_SET_PARAMS, &s->params); |
a7954218 AZ |
325 | /* TODO: TX ON/OFF */ |
326 | break; | |
327 | case DeviceInVendor | FTDI_GET_MDM_ST: | |
abb8a139 AJ |
328 | data[0] = usb_get_modem_lines(s) | 1; |
329 | data[1] = 0; | |
9a77a0f5 | 330 | p->actual_length = 2; |
a7954218 AZ |
331 | break; |
332 | case DeviceOutVendor | FTDI_SET_EVENT_CHR: | |
333 | /* TODO: handle it */ | |
334 | s->event_chr = value; | |
335 | break; | |
336 | case DeviceOutVendor | FTDI_SET_ERROR_CHR: | |
337 | /* TODO: handle it */ | |
338 | s->error_chr = value; | |
339 | break; | |
340 | case DeviceOutVendor | FTDI_SET_LATENCY: | |
341 | s->latency = value; | |
342 | break; | |
343 | case DeviceInVendor | FTDI_GET_LATENCY: | |
344 | data[0] = s->latency; | |
9a77a0f5 | 345 | p->actual_length = 1; |
a7954218 AZ |
346 | break; |
347 | default: | |
348 | fail: | |
349 | DPRINTF("got unsupported/bogus control %x, value %x\n", request, value); | |
9a77a0f5 | 350 | p->status = USB_RET_STALL; |
a7954218 AZ |
351 | break; |
352 | } | |
a7954218 AZ |
353 | } |
354 | ||
9a77a0f5 | 355 | static void usb_serial_handle_data(USBDevice *dev, USBPacket *p) |
a7954218 AZ |
356 | { |
357 | USBSerialState *s = (USBSerialState *)dev; | |
079d0b7f | 358 | uint8_t devep = p->ep->nr; |
9440b7e5 GH |
359 | struct iovec *iov; |
360 | uint8_t header[2]; | |
9a77a0f5 | 361 | int i, first_len, len; |
a7954218 AZ |
362 | |
363 | switch (p->pid) { | |
364 | case USB_TOKEN_OUT: | |
365 | if (devep != 2) | |
366 | goto fail; | |
9440b7e5 GH |
367 | for (i = 0; i < p->iov.niov; i++) { |
368 | iov = p->iov.iov + i; | |
6ab3fc32 DB |
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); | |
9440b7e5 | 372 | } |
9a77a0f5 | 373 | p->actual_length = p->iov.size; |
a7954218 AZ |
374 | break; |
375 | ||
376 | case USB_TOKEN_IN: | |
377 | if (devep != 1) | |
378 | goto fail; | |
379 | first_len = RECV_BUF - s->recv_ptr; | |
9440b7e5 | 380 | len = p->iov.size; |
a7954218 | 381 | if (len <= 2) { |
9a77a0f5 | 382 | p->status = USB_RET_NAK; |
a7954218 AZ |
383 | break; |
384 | } | |
9440b7e5 | 385 | header[0] = usb_get_modem_lines(s) | 1; |
abb8a139 | 386 | /* We do not have the uart details */ |
7e57f049 JW |
387 | /* handle serial break */ |
388 | if (s->event_trigger && s->event_trigger & FTDI_BI) { | |
389 | s->event_trigger &= ~FTDI_BI; | |
9440b7e5 GH |
390 | header[1] = FTDI_BI; |
391 | usb_packet_copy(p, header, 2); | |
7e57f049 JW |
392 | break; |
393 | } else { | |
9440b7e5 | 394 | header[1] = 0; |
7e57f049 | 395 | } |
a7954218 AZ |
396 | len -= 2; |
397 | if (len > s->recv_used) | |
398 | len = s->recv_used; | |
399 | if (!len) { | |
9a77a0f5 | 400 | p->status = USB_RET_NAK; |
a7954218 AZ |
401 | break; |
402 | } | |
403 | if (first_len > len) | |
404 | first_len = len; | |
9440b7e5 GH |
405 | usb_packet_copy(p, header, 2); |
406 | usb_packet_copy(p, s->recv_buf + s->recv_ptr, first_len); | |
a7954218 | 407 | if (len > first_len) |
9440b7e5 | 408 | usb_packet_copy(p, s->recv_buf, len - first_len); |
a7954218 AZ |
409 | s->recv_used -= len; |
410 | s->recv_ptr = (s->recv_ptr + len) % RECV_BUF; | |
a7954218 AZ |
411 | break; |
412 | ||
413 | default: | |
414 | DPRINTF("Bad token\n"); | |
415 | fail: | |
9a77a0f5 | 416 | p->status = USB_RET_STALL; |
a7954218 AZ |
417 | break; |
418 | } | |
a7954218 AZ |
419 | } |
420 | ||
8fcd3692 | 421 | static int usb_serial_can_read(void *opaque) |
a7954218 AZ |
422 | { |
423 | USBSerialState *s = opaque; | |
da124e62 GH |
424 | |
425 | if (!s->dev.attached) { | |
426 | return 0; | |
427 | } | |
a7954218 AZ |
428 | return RECV_BUF - s->recv_used; |
429 | } | |
430 | ||
8fcd3692 | 431 | static void usb_serial_read(void *opaque, const uint8_t *buf, int size) |
a7954218 AZ |
432 | { |
433 | USBSerialState *s = opaque; | |
4ab4183d DA |
434 | int first_size, start; |
435 | ||
436 | /* room in the buffer? */ | |
437 | if (size > (RECV_BUF - s->recv_used)) | |
438 | size = RECV_BUF - s->recv_used; | |
439 | ||
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) | |
445 | first_size = size; | |
446 | ||
447 | memcpy(s->recv_buf + start, buf, first_size); | |
448 | ||
449 | /* wrap around to front if needed */ | |
450 | if (size > first_size) | |
451 | memcpy(s->recv_buf, buf + first_size, size - first_size); | |
452 | } else { | |
453 | start -= RECV_BUF; | |
454 | memcpy(s->recv_buf + start, buf, size); | |
455 | } | |
a7954218 AZ |
456 | s->recv_used += size; |
457 | } | |
458 | ||
8fcd3692 | 459 | static void usb_serial_event(void *opaque, int event) |
a7954218 AZ |
460 | { |
461 | USBSerialState *s = opaque; | |
462 | ||
463 | switch (event) { | |
464 | case CHR_EVENT_BREAK: | |
7e57f049 | 465 | s->event_trigger |= FTDI_BI; |
a7954218 AZ |
466 | break; |
467 | case CHR_EVENT_FOCUS: | |
468 | break; | |
b6b8df56 | 469 | case CHR_EVENT_OPENED: |
da124e62 | 470 | if (!s->dev.attached) { |
7334d650 | 471 | usb_device_attach(&s->dev, &error_abort); |
da124e62 GH |
472 | } |
473 | break; | |
474 | case CHR_EVENT_CLOSED: | |
475 | if (s->dev.attached) { | |
476 | usb_device_detach(&s->dev); | |
477 | } | |
a7954218 AZ |
478 | break; |
479 | } | |
480 | } | |
481 | ||
38fff2c9 | 482 | static void usb_serial_realize(USBDevice *dev, Error **errp) |
806b6024 | 483 | { |
cdf0d769 | 484 | USBSerialState *s = USB_SERIAL_DEV(dev); |
7334d650 | 485 | Error *local_err = NULL; |
a980a065 | 486 | |
9d55d1ad | 487 | usb_desc_create_serial(dev); |
a980a065 | 488 | usb_desc_init(dev); |
da124e62 | 489 | dev->auto_attach = 0; |
2b0efdc3 | 490 | |
81bf96d3 | 491 | if (!s->cs) { |
38fff2c9 GA |
492 | error_setg(errp, "Property chardev is required"); |
493 | return; | |
81bf96d3 MA |
494 | } |
495 | ||
7334d650 GA |
496 | usb_check_attach(dev, &local_err); |
497 | if (local_err) { | |
498 | error_propagate(errp, local_err); | |
499 | return; | |
500 | } | |
501 | ||
2b0efdc3 GH |
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); | |
da124e62 | 505 | |
16665b94 | 506 | if (s->cs->be_open && !dev->attached) { |
7334d650 | 507 | usb_device_attach(dev, &error_abort); |
da124e62 | 508 | } |
806b6024 GH |
509 | } |
510 | ||
3741715c | 511 | static USBDevice *usb_serial_init(USBBus *bus, const char *filename) |
a7954218 | 512 | { |
806b6024 | 513 | USBDevice *dev; |
a7954218 | 514 | CharDriverState *cdrv; |
2b0efdc3 | 515 | uint32_t vendorid = 0, productid = 0; |
5ccfae10 AL |
516 | char label[32]; |
517 | static int index; | |
a7954218 AZ |
518 | |
519 | while (*filename && *filename != ':') { | |
520 | const char *p; | |
521 | char *e; | |
522 | if (strstart(filename, "vendorid=", &p)) { | |
523 | vendorid = strtol(p, &e, 16); | |
524 | if (e == p || (*e && *e != ',' && *e != ':')) { | |
1ecda02b | 525 | error_report("bogus vendor ID %s", p); |
a7954218 AZ |
526 | return NULL; |
527 | } | |
528 | filename = e; | |
529 | } else if (strstart(filename, "productid=", &p)) { | |
530 | productid = strtol(p, &e, 16); | |
531 | if (e == p || (*e && *e != ',' && *e != ':')) { | |
1ecda02b | 532 | error_report("bogus product ID %s", p); |
a7954218 AZ |
533 | return NULL; |
534 | } | |
535 | filename = e; | |
536 | } else { | |
1ecda02b | 537 | error_report("unrecognized serial USB option %s", filename); |
a7954218 AZ |
538 | return NULL; |
539 | } | |
540 | while(*filename == ',') | |
541 | filename++; | |
542 | } | |
543 | if (!*filename) { | |
1ecda02b | 544 | error_report("character device specification needed"); |
a7954218 AZ |
545 | return NULL; |
546 | } | |
547 | filename++; | |
a7954218 | 548 | |
5ccfae10 | 549 | snprintf(label, sizeof(label), "usbserial%d", index++); |
27143a44 | 550 | cdrv = qemu_chr_new(label, filename, NULL); |
a7954218 | 551 | if (!cdrv) |
806b6024 | 552 | return NULL; |
a7954218 | 553 | |
3741715c | 554 | dev = usb_create(bus, "usb-serial"); |
2b0efdc3 GH |
555 | qdev_prop_set_chr(&dev->qdev, "chardev", cdrv); |
556 | if (vendorid) | |
557 | qdev_prop_set_uint16(&dev->qdev, "vendorid", vendorid); | |
558 | if (productid) | |
559 | qdev_prop_set_uint16(&dev->qdev, "productid", productid); | |
2b0efdc3 GH |
560 | return dev; |
561 | } | |
562 | ||
3741715c | 563 | static USBDevice *usb_braille_init(USBBus *bus, const char *unused) |
2b0efdc3 GH |
564 | { |
565 | USBDevice *dev; | |
566 | CharDriverState *cdrv; | |
567 | ||
27143a44 | 568 | cdrv = qemu_chr_new("braille", "braille", NULL); |
2b0efdc3 GH |
569 | if (!cdrv) |
570 | return NULL; | |
806b6024 | 571 | |
3741715c | 572 | dev = usb_create(bus, "usb-braille"); |
2b0efdc3 | 573 | qdev_prop_set_chr(&dev->qdev, "chardev", cdrv); |
2b0efdc3 | 574 | return dev; |
a7954218 | 575 | } |
806b6024 | 576 | |
98e51ec9 GH |
577 | static const VMStateDescription vmstate_usb_serial = { |
578 | .name = "usb-serial", | |
579 | .unmigratable = 1, | |
580 | }; | |
581 | ||
39bffca2 AL |
582 | static Property serial_properties[] = { |
583 | DEFINE_PROP_CHR("chardev", USBSerialState, cs), | |
584 | DEFINE_PROP_END_OF_LIST(), | |
585 | }; | |
586 | ||
cdf0d769 | 587 | static void usb_serial_dev_class_init(ObjectClass *klass, void *data) |
62aed765 | 588 | { |
39bffca2 | 589 | DeviceClass *dc = DEVICE_CLASS(klass); |
62aed765 AL |
590 | USBDeviceClass *uc = USB_DEVICE_CLASS(klass); |
591 | ||
cdf0d769 | 592 | uc->realize = usb_serial_realize; |
62aed765 AL |
593 | uc->handle_reset = usb_serial_handle_reset; |
594 | uc->handle_control = usb_serial_handle_control; | |
595 | uc->handle_data = usb_serial_handle_data; | |
39bffca2 | 596 | dc->vmsd = &vmstate_usb_serial; |
125ee0ed | 597 | set_bit(DEVICE_CATEGORY_INPUT, dc->categories); |
62aed765 AL |
598 | } |
599 | ||
cdf0d769 GA |
600 | static const TypeInfo usb_serial_dev_type_info = { |
601 | .name = TYPE_USB_SERIAL, | |
602 | .parent = TYPE_USB_DEVICE, | |
603 | .instance_size = sizeof(USBSerialState), | |
604 | .abstract = true, | |
605 | .class_init = usb_serial_dev_class_init, | |
606 | }; | |
607 | ||
608 | static void usb_serial_class_initfn(ObjectClass *klass, void *data) | |
609 | { | |
610 | DeviceClass *dc = DEVICE_CLASS(klass); | |
611 | USBDeviceClass *uc = USB_DEVICE_CLASS(klass); | |
612 | ||
613 | uc->product_desc = "QEMU USB Serial"; | |
614 | uc->usb_desc = &desc_serial; | |
615 | dc->props = serial_properties; | |
616 | } | |
617 | ||
8c43a6f0 | 618 | static const TypeInfo serial_info = { |
39bffca2 | 619 | .name = "usb-serial", |
cdf0d769 | 620 | .parent = TYPE_USB_SERIAL, |
39bffca2 AL |
621 | .class_init = usb_serial_class_initfn, |
622 | }; | |
623 | ||
624 | static Property braille_properties[] = { | |
625 | DEFINE_PROP_CHR("chardev", USBSerialState, cs), | |
626 | DEFINE_PROP_END_OF_LIST(), | |
2b0efdc3 GH |
627 | }; |
628 | ||
62aed765 AL |
629 | static void usb_braille_class_initfn(ObjectClass *klass, void *data) |
630 | { | |
39bffca2 | 631 | DeviceClass *dc = DEVICE_CLASS(klass); |
62aed765 AL |
632 | USBDeviceClass *uc = USB_DEVICE_CLASS(klass); |
633 | ||
62aed765 AL |
634 | uc->product_desc = "QEMU USB Braille"; |
635 | uc->usb_desc = &desc_braille; | |
39bffca2 | 636 | dc->props = braille_properties; |
62aed765 AL |
637 | } |
638 | ||
8c43a6f0 | 639 | static const TypeInfo braille_info = { |
39bffca2 | 640 | .name = "usb-braille", |
cdf0d769 | 641 | .parent = TYPE_USB_SERIAL, |
39bffca2 | 642 | .class_init = usb_braille_class_initfn, |
806b6024 GH |
643 | }; |
644 | ||
83f7d43a | 645 | static void usb_serial_register_types(void) |
806b6024 | 646 | { |
cdf0d769 | 647 | type_register_static(&usb_serial_dev_type_info); |
39bffca2 | 648 | type_register_static(&serial_info); |
ba02430f | 649 | usb_legacy_register("usb-serial", "serial", usb_serial_init); |
39bffca2 | 650 | type_register_static(&braille_info); |
ba02430f | 651 | usb_legacy_register("usb-braille", "braille", usb_braille_init); |
806b6024 | 652 | } |
83f7d43a AF |
653 | |
654 | type_init(usb_serial_register_types) |