![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dev-hid.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / hw / usb|
Return to dev-hid.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw / usb |
1.1 root 1: /*
2: * QEMU USB HID devices
3: *
4: * Copyright (c) 2005 Fabrice Bellard
5: * Copyright (c) 2007 OpenMoko, Inc. ([email protected])
6: *
7: * Permission is hereby granted, free of charge, to any person obtaining a copy
8: * of this software and associated documentation files (the "Software"), to deal
9: * in the Software without restriction, including without limitation the rights
10: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11: * copies of the Software, and to permit persons to whom the Software is
12: * furnished to do so, subject to the following conditions:
13: *
14: * The above copyright notice and this permission notice shall be included in
15: * all copies or substantial portions of the Software.
16: *
17: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23: * THE SOFTWARE.
24: */
25: #include "hw/hw.h"
26: #include "console.h"
27: #include "hw/usb.h"
28: #include "hw/usb/desc.h"
29: #include "qemu-timer.h"
30: #include "hw/hid.h"
31:
32: /* HID interface requests */
33: #define GET_REPORT 0xa101
34: #define GET_IDLE 0xa102
35: #define GET_PROTOCOL 0xa103
36: #define SET_REPORT 0x2109
37: #define SET_IDLE 0x210a
38: #define SET_PROTOCOL 0x210b
39:
40: /* HID descriptor types */
41: #define USB_DT_HID 0x21
42: #define USB_DT_REPORT 0x22
43: #define USB_DT_PHY 0x23
44:
45: typedef struct USBHIDState {
46: USBDevice dev;
47: USBEndpoint *intr;
48: HIDState hid;
49: } USBHIDState;
50:
51: enum {
52: STR_MANUFACTURER = 1,
53: STR_PRODUCT_MOUSE,
54: STR_PRODUCT_TABLET,
55: STR_PRODUCT_KEYBOARD,
56: STR_SERIALNUMBER,
57: STR_CONFIG_MOUSE,
58: STR_CONFIG_TABLET,
59: STR_CONFIG_KEYBOARD,
60: };
61:
62: static const USBDescStrings desc_strings = {
63: [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
64: [STR_PRODUCT_MOUSE] = "QEMU USB Mouse",
65: [STR_PRODUCT_TABLET] = "QEMU USB Tablet",
66: [STR_PRODUCT_KEYBOARD] = "QEMU USB Keyboard",
67: [STR_SERIALNUMBER] = "42", /* == remote wakeup works */
68: [STR_CONFIG_MOUSE] = "HID Mouse",
69: [STR_CONFIG_TABLET] = "HID Tablet",
70: [STR_CONFIG_KEYBOARD] = "HID Keyboard",
71: };
72:
73: static const USBDescIface desc_iface_mouse = {
74: .bInterfaceNumber = 0,
75: .bNumEndpoints = 1,
76: .bInterfaceClass = USB_CLASS_HID,
77: .bInterfaceSubClass = 0x01, /* boot */
78: .bInterfaceProtocol = 0x02,
79: .ndesc = 1,
80: .descs = (USBDescOther[]) {
81: {
82: /* HID descriptor */
83: .data = (uint8_t[]) {
84: 0x09, /* u8 bLength */
85: USB_DT_HID, /* u8 bDescriptorType */
86: 0x01, 0x00, /* u16 HID_class */
87: 0x00, /* u8 country_code */
88: 0x01, /* u8 num_descriptors */
89: USB_DT_REPORT, /* u8 type: Report */
90: 52, 0, /* u16 len */
91: },
92: },
93: },
94: .eps = (USBDescEndpoint[]) {
95: {
96: .bEndpointAddress = USB_DIR_IN | 0x01,
97: .bmAttributes = USB_ENDPOINT_XFER_INT,
98: .wMaxPacketSize = 4,
99: .bInterval = 0x0a,
100: },
101: },
102: };
103:
104: static const USBDescIface desc_iface_tablet = {
105: .bInterfaceNumber = 0,
106: .bNumEndpoints = 1,
107: .bInterfaceClass = USB_CLASS_HID,
108: .bInterfaceProtocol = 0x02,
109: .ndesc = 1,
110: .descs = (USBDescOther[]) {
111: {
112: /* HID descriptor */
113: .data = (uint8_t[]) {
114: 0x09, /* u8 bLength */
115: USB_DT_HID, /* u8 bDescriptorType */
116: 0x01, 0x00, /* u16 HID_class */
117: 0x00, /* u8 country_code */
118: 0x01, /* u8 num_descriptors */
119: USB_DT_REPORT, /* u8 type: Report */
120: 74, 0, /* u16 len */
121: },
122: },
123: },
124: .eps = (USBDescEndpoint[]) {
125: {
126: .bEndpointAddress = USB_DIR_IN | 0x01,
127: .bmAttributes = USB_ENDPOINT_XFER_INT,
128: .wMaxPacketSize = 8,
129: .bInterval = 0x0a,
130: },
131: },
132: };
133:
134: static const USBDescIface desc_iface_keyboard = {
135: .bInterfaceNumber = 0,
136: .bNumEndpoints = 1,
137: .bInterfaceClass = USB_CLASS_HID,
138: .bInterfaceSubClass = 0x01, /* boot */
139: .bInterfaceProtocol = 0x01, /* keyboard */
140: .ndesc = 1,
141: .descs = (USBDescOther[]) {
142: {
143: /* HID descriptor */
144: .data = (uint8_t[]) {
145: 0x09, /* u8 bLength */
146: USB_DT_HID, /* u8 bDescriptorType */
147: 0x11, 0x01, /* u16 HID_class */
148: 0x00, /* u8 country_code */
149: 0x01, /* u8 num_descriptors */
150: USB_DT_REPORT, /* u8 type: Report */
151: 0x3f, 0, /* u16 len */
152: },
153: },
154: },
155: .eps = (USBDescEndpoint[]) {
156: {
157: .bEndpointAddress = USB_DIR_IN | 0x01,
158: .bmAttributes = USB_ENDPOINT_XFER_INT,
159: .wMaxPacketSize = 8,
160: .bInterval = 0x0a,
161: },
162: },
163: };
164:
165: static const USBDescDevice desc_device_mouse = {
166: .bcdUSB = 0x0100,
167: .bMaxPacketSize0 = 8,
168: .bNumConfigurations = 1,
169: .confs = (USBDescConfig[]) {
170: {
171: .bNumInterfaces = 1,
172: .bConfigurationValue = 1,
173: .iConfiguration = STR_CONFIG_MOUSE,
174: .bmAttributes = 0xa0,
175: .bMaxPower = 50,
176: .nif = 1,
177: .ifs = &desc_iface_mouse,
178: },
179: },
180: };
181:
182: static const USBDescDevice desc_device_tablet = {
183: .bcdUSB = 0x0100,
184: .bMaxPacketSize0 = 8,
185: .bNumConfigurations = 1,
186: .confs = (USBDescConfig[]) {
187: {
188: .bNumInterfaces = 1,
189: .bConfigurationValue = 1,
190: .iConfiguration = STR_CONFIG_TABLET,
191: .bmAttributes = 0xa0,
192: .bMaxPower = 50,
193: .nif = 1,
194: .ifs = &desc_iface_tablet,
195: },
196: },
197: };
198:
199: static const USBDescDevice desc_device_keyboard = {
200: .bcdUSB = 0x0100,
201: .bMaxPacketSize0 = 8,
202: .bNumConfigurations = 1,
203: .confs = (USBDescConfig[]) {
204: {
205: .bNumInterfaces = 1,
206: .bConfigurationValue = 1,
207: .iConfiguration = STR_CONFIG_KEYBOARD,
208: .bmAttributes = 0xa0,
209: .bMaxPower = 50,
210: .nif = 1,
211: .ifs = &desc_iface_keyboard,
212: },
213: },
214: };
215:
216: static const USBDesc desc_mouse = {
217: .id = {
218: .idVendor = 0x0627,
219: .idProduct = 0x0001,
220: .bcdDevice = 0,
221: .iManufacturer = STR_MANUFACTURER,
222: .iProduct = STR_PRODUCT_MOUSE,
223: .iSerialNumber = STR_SERIALNUMBER,
224: },
225: .full = &desc_device_mouse,
226: .str = desc_strings,
227: };
228:
229: static const USBDesc desc_tablet = {
230: .id = {
231: .idVendor = 0x0627,
232: .idProduct = 0x0001,
233: .bcdDevice = 0,
234: .iManufacturer = STR_MANUFACTURER,
235: .iProduct = STR_PRODUCT_TABLET,
236: .iSerialNumber = STR_SERIALNUMBER,
237: },
238: .full = &desc_device_tablet,
239: .str = desc_strings,
240: };
241:
242: static const USBDesc desc_keyboard = {
243: .id = {
244: .idVendor = 0x0627,
245: .idProduct = 0x0001,
246: .bcdDevice = 0,
247: .iManufacturer = STR_MANUFACTURER,
248: .iProduct = STR_PRODUCT_KEYBOARD,
249: .iSerialNumber = STR_SERIALNUMBER,
250: },
251: .full = &desc_device_keyboard,
252: .str = desc_strings,
253: };
254:
255: static const uint8_t qemu_mouse_hid_report_descriptor[] = {
256: 0x05, 0x01, /* Usage Page (Generic Desktop) */
257: 0x09, 0x02, /* Usage (Mouse) */
258: 0xa1, 0x01, /* Collection (Application) */
259: 0x09, 0x01, /* Usage (Pointer) */
260: 0xa1, 0x00, /* Collection (Physical) */
261: 0x05, 0x09, /* Usage Page (Button) */
262: 0x19, 0x01, /* Usage Minimum (1) */
263: 0x29, 0x03, /* Usage Maximum (3) */
264: 0x15, 0x00, /* Logical Minimum (0) */
265: 0x25, 0x01, /* Logical Maximum (1) */
266: 0x95, 0x03, /* Report Count (3) */
267: 0x75, 0x01, /* Report Size (1) */
268: 0x81, 0x02, /* Input (Data, Variable, Absolute) */
269: 0x95, 0x01, /* Report Count (1) */
270: 0x75, 0x05, /* Report Size (5) */
271: 0x81, 0x01, /* Input (Constant) */
272: 0x05, 0x01, /* Usage Page (Generic Desktop) */
273: 0x09, 0x30, /* Usage (X) */
274: 0x09, 0x31, /* Usage (Y) */
275: 0x09, 0x38, /* Usage (Wheel) */
276: 0x15, 0x81, /* Logical Minimum (-0x7f) */
277: 0x25, 0x7f, /* Logical Maximum (0x7f) */
278: 0x75, 0x08, /* Report Size (8) */
279: 0x95, 0x03, /* Report Count (3) */
280: 0x81, 0x06, /* Input (Data, Variable, Relative) */
281: 0xc0, /* End Collection */
282: 0xc0, /* End Collection */
283: };
284:
285: static const uint8_t qemu_tablet_hid_report_descriptor[] = {
286: 0x05, 0x01, /* Usage Page (Generic Desktop) */
287: 0x09, 0x01, /* Usage (Pointer) */
288: 0xa1, 0x01, /* Collection (Application) */
289: 0x09, 0x01, /* Usage (Pointer) */
290: 0xa1, 0x00, /* Collection (Physical) */
291: 0x05, 0x09, /* Usage Page (Button) */
292: 0x19, 0x01, /* Usage Minimum (1) */
293: 0x29, 0x03, /* Usage Maximum (3) */
294: 0x15, 0x00, /* Logical Minimum (0) */
295: 0x25, 0x01, /* Logical Maximum (1) */
296: 0x95, 0x03, /* Report Count (3) */
297: 0x75, 0x01, /* Report Size (1) */
298: 0x81, 0x02, /* Input (Data, Variable, Absolute) */
299: 0x95, 0x01, /* Report Count (1) */
300: 0x75, 0x05, /* Report Size (5) */
301: 0x81, 0x01, /* Input (Constant) */
302: 0x05, 0x01, /* Usage Page (Generic Desktop) */
303: 0x09, 0x30, /* Usage (X) */
304: 0x09, 0x31, /* Usage (Y) */
305: 0x15, 0x00, /* Logical Minimum (0) */
306: 0x26, 0xff, 0x7f, /* Logical Maximum (0x7fff) */
307: 0x35, 0x00, /* Physical Minimum (0) */
308: 0x46, 0xff, 0x7f, /* Physical Maximum (0x7fff) */
309: 0x75, 0x10, /* Report Size (16) */
310: 0x95, 0x02, /* Report Count (2) */
311: 0x81, 0x02, /* Input (Data, Variable, Absolute) */
312: 0x05, 0x01, /* Usage Page (Generic Desktop) */
313: 0x09, 0x38, /* Usage (Wheel) */
314: 0x15, 0x81, /* Logical Minimum (-0x7f) */
315: 0x25, 0x7f, /* Logical Maximum (0x7f) */
316: 0x35, 0x00, /* Physical Minimum (same as logical) */
317: 0x45, 0x00, /* Physical Maximum (same as logical) */
318: 0x75, 0x08, /* Report Size (8) */
319: 0x95, 0x01, /* Report Count (1) */
320: 0x81, 0x06, /* Input (Data, Variable, Relative) */
321: 0xc0, /* End Collection */
322: 0xc0, /* End Collection */
323: };
324:
325: static const uint8_t qemu_keyboard_hid_report_descriptor[] = {
326: 0x05, 0x01, /* Usage Page (Generic Desktop) */
327: 0x09, 0x06, /* Usage (Keyboard) */
328: 0xa1, 0x01, /* Collection (Application) */
329: 0x75, 0x01, /* Report Size (1) */
330: 0x95, 0x08, /* Report Count (8) */
331: 0x05, 0x07, /* Usage Page (Key Codes) */
332: 0x19, 0xe0, /* Usage Minimum (224) */
333: 0x29, 0xe7, /* Usage Maximum (231) */
334: 0x15, 0x00, /* Logical Minimum (0) */
335: 0x25, 0x01, /* Logical Maximum (1) */
336: 0x81, 0x02, /* Input (Data, Variable, Absolute) */
337: 0x95, 0x01, /* Report Count (1) */
338: 0x75, 0x08, /* Report Size (8) */
339: 0x81, 0x01, /* Input (Constant) */
340: 0x95, 0x05, /* Report Count (5) */
341: 0x75, 0x01, /* Report Size (1) */
342: 0x05, 0x08, /* Usage Page (LEDs) */
343: 0x19, 0x01, /* Usage Minimum (1) */
344: 0x29, 0x05, /* Usage Maximum (5) */
345: 0x91, 0x02, /* Output (Data, Variable, Absolute) */
346: 0x95, 0x01, /* Report Count (1) */
347: 0x75, 0x03, /* Report Size (3) */
348: 0x91, 0x01, /* Output (Constant) */
349: 0x95, 0x06, /* Report Count (6) */
350: 0x75, 0x08, /* Report Size (8) */
351: 0x15, 0x00, /* Logical Minimum (0) */
352: 0x25, 0xff, /* Logical Maximum (255) */
353: 0x05, 0x07, /* Usage Page (Key Codes) */
354: 0x19, 0x00, /* Usage Minimum (0) */
355: 0x29, 0xff, /* Usage Maximum (255) */
356: 0x81, 0x00, /* Input (Data, Array) */
357: 0xc0, /* End Collection */
358: };
359:
360: static void usb_hid_changed(HIDState *hs)
361: {
362: USBHIDState *us = container_of(hs, USBHIDState, hid);
363:
364: usb_wakeup(us->intr);
365: }
366:
367: static void usb_hid_handle_reset(USBDevice *dev)
368: {
369: USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
370:
371: hid_reset(&us->hid);
372: }
373:
374: static int usb_hid_handle_control(USBDevice *dev, USBPacket *p,
375: int request, int value, int index, int length, uint8_t *data)
376: {
377: USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
378: HIDState *hs = &us->hid;
379: int ret;
380:
381: ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
382: if (ret >= 0) {
383: return ret;
384: }
385:
386: ret = 0;
387: switch (request) {
388: /* hid specific requests */
389: case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
390: switch (value >> 8) {
391: case 0x22:
392: if (hs->kind == HID_MOUSE) {
393: memcpy(data, qemu_mouse_hid_report_descriptor,
394: sizeof(qemu_mouse_hid_report_descriptor));
395: ret = sizeof(qemu_mouse_hid_report_descriptor);
396: } else if (hs->kind == HID_TABLET) {
397: memcpy(data, qemu_tablet_hid_report_descriptor,
398: sizeof(qemu_tablet_hid_report_descriptor));
399: ret = sizeof(qemu_tablet_hid_report_descriptor);
400: } else if (hs->kind == HID_KEYBOARD) {
401: memcpy(data, qemu_keyboard_hid_report_descriptor,
402: sizeof(qemu_keyboard_hid_report_descriptor));
403: ret = sizeof(qemu_keyboard_hid_report_descriptor);
404: }
405: break;
406: default:
407: goto fail;
408: }
409: break;
410: case GET_REPORT:
411: if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
412: ret = hid_pointer_poll(hs, data, length);
413: } else if (hs->kind == HID_KEYBOARD) {
414: ret = hid_keyboard_poll(hs, data, length);
415: }
416: break;
417: case SET_REPORT:
418: if (hs->kind == HID_KEYBOARD) {
419: ret = hid_keyboard_write(hs, data, length);
420: } else {
421: goto fail;
422: }
423: break;
424: case GET_PROTOCOL:
425: if (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) {
426: goto fail;
427: }
428: ret = 1;
429: data[0] = hs->protocol;
430: break;
431: case SET_PROTOCOL:
432: if (hs->kind != HID_KEYBOARD && hs->kind != HID_MOUSE) {
433: goto fail;
434: }
435: ret = 0;
436: hs->protocol = value;
437: break;
438: case GET_IDLE:
439: ret = 1;
440: data[0] = hs->idle;
441: break;
442: case SET_IDLE:
443: hs->idle = (uint8_t) (value >> 8);
444: hid_set_next_idle(hs, qemu_get_clock_ns(vm_clock));
445: if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
446: hid_pointer_activate(hs);
447: }
448: ret = 0;
449: break;
450: default:
451: fail:
452: ret = USB_RET_STALL;
453: break;
454: }
455: return ret;
456: }
457:
458: static int usb_hid_handle_data(USBDevice *dev, USBPacket *p)
459: {
460: USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
461: HIDState *hs = &us->hid;
462: uint8_t buf[p->iov.size];
463: int ret = 0;
464:
465: switch (p->pid) {
466: case USB_TOKEN_IN:
467: if (p->ep->nr == 1) {
468: int64_t curtime = qemu_get_clock_ns(vm_clock);
469: if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
470: hid_pointer_activate(hs);
471: }
472: if (!hid_has_events(hs) &&
473: (!hs->idle || hs->next_idle_clock - curtime > 0)) {
474: return USB_RET_NAK;
475: }
476: hid_set_next_idle(hs, curtime);
477: if (hs->kind == HID_MOUSE || hs->kind == HID_TABLET) {
478: ret = hid_pointer_poll(hs, buf, p->iov.size);
479: } else if (hs->kind == HID_KEYBOARD) {
480: ret = hid_keyboard_poll(hs, buf, p->iov.size);
481: }
482: usb_packet_copy(p, buf, ret);
483: } else {
484: goto fail;
485: }
486: break;
487: case USB_TOKEN_OUT:
488: default:
489: fail:
490: ret = USB_RET_STALL;
491: break;
492: }
493: return ret;
494: }
495:
496: static void usb_hid_handle_destroy(USBDevice *dev)
497: {
498: USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
499:
500: hid_free(&us->hid);
501: }
502:
503: static int usb_hid_initfn(USBDevice *dev, int kind)
504: {
505: USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev);
506:
507: usb_desc_init(dev);
508: us->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
509: hid_init(&us->hid, kind, usb_hid_changed);
510: return 0;
511: }
512:
513: static int usb_tablet_initfn(USBDevice *dev)
514: {
515: return usb_hid_initfn(dev, HID_TABLET);
516: }
517:
518: static int usb_mouse_initfn(USBDevice *dev)
519: {
520: return usb_hid_initfn(dev, HID_MOUSE);
521: }
522:
523: static int usb_keyboard_initfn(USBDevice *dev)
524: {
525: return usb_hid_initfn(dev, HID_KEYBOARD);
526: }
527:
528: static int usb_ptr_post_load(void *opaque, int version_id)
529: {
530: USBHIDState *s = opaque;
531:
532: if (s->dev.remote_wakeup) {
533: hid_pointer_activate(&s->hid);
534: }
535: return 0;
536: }
537:
538: static const VMStateDescription vmstate_usb_ptr = {
539: .name = "usb-ptr",
540: .version_id = 1,
541: .minimum_version_id = 1,
542: .post_load = usb_ptr_post_load,
543: .fields = (VMStateField []) {
544: VMSTATE_USB_DEVICE(dev, USBHIDState),
545: VMSTATE_HID_POINTER_DEVICE(hid, USBHIDState),
546: VMSTATE_END_OF_LIST()
547: }
548: };
549:
550: static const VMStateDescription vmstate_usb_kbd = {
551: .name = "usb-kbd",
552: .version_id = 1,
553: .minimum_version_id = 1,
554: .fields = (VMStateField []) {
555: VMSTATE_USB_DEVICE(dev, USBHIDState),
556: VMSTATE_HID_KEYBOARD_DEVICE(hid, USBHIDState),
557: VMSTATE_END_OF_LIST()
558: }
559: };
560:
561: static void usb_hid_class_initfn(ObjectClass *klass, void *data)
562: {
563: USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
564:
565: uc->handle_reset = usb_hid_handle_reset;
566: uc->handle_control = usb_hid_handle_control;
567: uc->handle_data = usb_hid_handle_data;
568: uc->handle_destroy = usb_hid_handle_destroy;
569: }
570:
571: static void usb_tablet_class_initfn(ObjectClass *klass, void *data)
572: {
573: DeviceClass *dc = DEVICE_CLASS(klass);
574: USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
575:
576: usb_hid_class_initfn(klass, data);
577: uc->init = usb_tablet_initfn;
578: uc->product_desc = "QEMU USB Tablet";
579: uc->usb_desc = &desc_tablet;
580: dc->vmsd = &vmstate_usb_ptr;
581: }
582:
583: static TypeInfo usb_tablet_info = {
584: .name = "usb-tablet",
585: .parent = TYPE_USB_DEVICE,
586: .instance_size = sizeof(USBHIDState),
587: .class_init = usb_tablet_class_initfn,
588: };
589:
590: static void usb_mouse_class_initfn(ObjectClass *klass, void *data)
591: {
592: DeviceClass *dc = DEVICE_CLASS(klass);
593: USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
594:
595: usb_hid_class_initfn(klass, data);
596: uc->init = usb_mouse_initfn;
597: uc->product_desc = "QEMU USB Mouse";
598: uc->usb_desc = &desc_mouse;
599: dc->vmsd = &vmstate_usb_ptr;
600: }
601:
602: static TypeInfo usb_mouse_info = {
603: .name = "usb-mouse",
604: .parent = TYPE_USB_DEVICE,
605: .instance_size = sizeof(USBHIDState),
606: .class_init = usb_mouse_class_initfn,
607: };
608:
609: static void usb_keyboard_class_initfn(ObjectClass *klass, void *data)
610: {
611: DeviceClass *dc = DEVICE_CLASS(klass);
612: USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
613:
614: usb_hid_class_initfn(klass, data);
615: uc->init = usb_keyboard_initfn;
616: uc->product_desc = "QEMU USB Keyboard";
617: uc->usb_desc = &desc_keyboard;
618: dc->vmsd = &vmstate_usb_kbd;
619: }
620:
621: static TypeInfo usb_keyboard_info = {
622: .name = "usb-kbd",
623: .parent = TYPE_USB_DEVICE,
624: .instance_size = sizeof(USBHIDState),
625: .class_init = usb_keyboard_class_initfn,
626: };
627:
628: static void usb_hid_register_types(void)
629: {
630: type_register_static(&usb_tablet_info);
631: usb_legacy_register("usb-tablet", "tablet", NULL);
632: type_register_static(&usb_mouse_info);
633: usb_legacy_register("usb-mouse", "mouse", NULL);
634: type_register_static(&usb_keyboard_info);
635: usb_legacy_register("usb-kbd", "keyboard", NULL);
636: }
637:
638: type_init(usb_hid_register_types)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.