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