![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dev-smartcard-reader.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-smartcard-reader.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw / usb |
1.1 root 1: /*
2: * Copyright (C) 2011 Red Hat, Inc.
3: *
4: * CCID Device emulation
5: *
6: * Written by Alon Levy, with contributions from Robert Relyea.
7: *
8: * Based on usb-serial.c, see its copyright and attributions below.
9: *
10: * This work is licensed under the terms of the GNU GPL, version 2.1 or later.
11: * See the COPYING file in the top-level directory.
12: * ------- (original copyright & attribution for usb-serial.c below) --------
13: * Copyright (c) 2006 CodeSourcery.
14: * Copyright (c) 2008 Samuel Thibault <[email protected]>
15: * Written by Paul Brook, reused for FTDI by Samuel Thibault,
16: */
17:
18: /*
19: * References:
20: *
21: * CCID Specification Revision 1.1 April 22nd 2005
22: * "Universal Serial Bus, Device Class: Smart Card"
23: * Specification for Integrated Circuit(s) Cards Interface Devices
24: *
25: * Endianness note: from the spec (1.3)
26: * "Fields that are larger than a byte are stored in little endian"
27: *
28: * KNOWN BUGS
29: * 1. remove/insert can sometimes result in removed state instead of inserted.
30: * This is a result of the following:
31: * symptom: dmesg shows ERMOTEIO (-121), pcscd shows -99. This can happen
32: * when a short packet is sent, as seen in uhci-usb.c, resulting from a urb
33: * from the guest requesting SPD and us returning a smaller packet.
34: * Not sure which messages trigger this.
35: */
36:
37: #include "qemu-common.h"
38: #include "qemu-error.h"
39: #include "hw/usb.h"
40: #include "hw/usb/desc.h"
41: #include "monitor.h"
42:
43: #include "hw/ccid.h"
44:
45: #define DPRINTF(s, lvl, fmt, ...) \
46: do { \
47: if (lvl <= s->debug) { \
48: printf("usb-ccid: " fmt , ## __VA_ARGS__); \
49: } \
50: } while (0)
51:
52: #define D_WARN 1
53: #define D_INFO 2
54: #define D_MORE_INFO 3
55: #define D_VERBOSE 4
56:
57: #define CCID_DEV_NAME "usb-ccid"
58:
59: /*
60: * The two options for variable sized buffers:
61: * make them constant size, for large enough constant,
62: * or handle the migration complexity - VMState doesn't handle this case.
63: * sizes are expected never to be exceeded, unless guest misbehaves.
64: */
65: #define BULK_OUT_DATA_SIZE 65536
66: #define PENDING_ANSWERS_NUM 128
67:
68: #define BULK_IN_BUF_SIZE 384
69: #define BULK_IN_PENDING_NUM 8
70:
71: #define InterfaceOutClass \
72: ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE)<<8)
73:
74: #define InterfaceInClass \
75: ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE)<<8)
76:
77: #define CCID_MAX_PACKET_SIZE 64
78:
79: #define CCID_CONTROL_ABORT 0x1
80: #define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
81: #define CCID_CONTROL_GET_DATA_RATES 0x3
82:
83: #define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
84: #define CCID_VENDOR_DESCRIPTION "QEMU " QEMU_VERSION
85: #define CCID_INTERFACE_NAME "CCID Interface"
86: #define CCID_SERIAL_NUMBER_STRING "1"
87: /*
88: * Using Gemplus Vendor and Product id
89: * Effect on various drivers:
90: * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
91: * linux has a number of class drivers, but openct filters based on
92: * vendor/product (/etc/openct.conf under fedora), hence Gemplus.
93: */
94: #define CCID_VENDOR_ID 0x08e6
95: #define CCID_PRODUCT_ID 0x4433
96: #define CCID_DEVICE_VERSION 0x0000
97:
98: /*
99: * BULK_OUT messages from PC to Reader
100: * Defined in CCID Rev 1.1 6.1 (page 26)
101: */
102: #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
103: #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
104: #define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
105: #define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
106: #define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
107: #define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
108: #define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
109: #define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
110: #define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
111: #define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
112: #define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
113: #define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
114: #define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
115: #define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
116:
117: /*
118: * BULK_IN messages from Reader to PC
119: * Defined in CCID Rev 1.1 6.2 (page 48)
120: */
121: #define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
122: #define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
123: #define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
124: #define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
125: #define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
126:
127: /*
128: * INTERRUPT_IN messages from Reader to PC
129: * Defined in CCID Rev 1.1 6.3 (page 56)
130: */
131: #define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
132: #define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
133:
134: /*
135: * Endpoints for CCID - addresses are up to us to decide.
136: * To support slot insertion and removal we must have an interrupt in ep
137: * in addition we need a bulk in and bulk out ep
138: * 5.2, page 20
139: */
140: #define CCID_INT_IN_EP 1
141: #define CCID_BULK_IN_EP 2
142: #define CCID_BULK_OUT_EP 3
143:
144: /* bmSlotICCState masks */
145: #define SLOT_0_STATE_MASK 1
146: #define SLOT_0_CHANGED_MASK 2
147:
148: /* Status codes that go in bStatus (see 6.2.6) */
149: enum {
150: ICC_STATUS_PRESENT_ACTIVE = 0,
151: ICC_STATUS_PRESENT_INACTIVE,
152: ICC_STATUS_NOT_PRESENT
153: };
154:
155: enum {
156: COMMAND_STATUS_NO_ERROR = 0,
157: COMMAND_STATUS_FAILED,
158: COMMAND_STATUS_TIME_EXTENSION_REQUIRED
159: };
160:
161: /* Error codes that go in bError (see 6.2.6) */
162: enum {
163: ERROR_CMD_NOT_SUPPORTED = 0,
164: ERROR_CMD_ABORTED = -1,
165: ERROR_ICC_MUTE = -2,
166: ERROR_XFR_PARITY_ERROR = -3,
167: ERROR_XFR_OVERRUN = -4,
168: ERROR_HW_ERROR = -5,
169: };
170:
171: /* 6.2.6 RDR_to_PC_SlotStatus definitions */
172: enum {
173: CLOCK_STATUS_RUNNING = 0,
174: /*
175: * 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
176: * 3 - unknown state. rest are RFU
177: */
178: };
179:
180: typedef struct QEMU_PACKED CCID_Header {
181: uint8_t bMessageType;
182: uint32_t dwLength;
183: uint8_t bSlot;
184: uint8_t bSeq;
185: } CCID_Header;
186:
187: typedef struct QEMU_PACKED CCID_BULK_IN {
188: CCID_Header hdr;
189: uint8_t bStatus; /* Only used in BULK_IN */
190: uint8_t bError; /* Only used in BULK_IN */
191: } CCID_BULK_IN;
192:
193: typedef struct QEMU_PACKED CCID_SlotStatus {
194: CCID_BULK_IN b;
195: uint8_t bClockStatus;
196: } CCID_SlotStatus;
197:
198: typedef struct QEMU_PACKED CCID_Parameter {
199: CCID_BULK_IN b;
200: uint8_t bProtocolNum;
201: uint8_t abProtocolDataStructure[0];
202: } CCID_Parameter;
203:
204: typedef struct QEMU_PACKED CCID_DataBlock {
205: CCID_BULK_IN b;
206: uint8_t bChainParameter;
207: uint8_t abData[0];
208: } CCID_DataBlock;
209:
210: /* 6.1.4 PC_to_RDR_XfrBlock */
211: typedef struct QEMU_PACKED CCID_XferBlock {
212: CCID_Header hdr;
213: uint8_t bBWI; /* Block Waiting Timeout */
214: uint16_t wLevelParameter; /* XXX currently unused */
215: uint8_t abData[0];
216: } CCID_XferBlock;
217:
218: typedef struct QEMU_PACKED CCID_IccPowerOn {
219: CCID_Header hdr;
220: uint8_t bPowerSelect;
221: uint16_t abRFU;
222: } CCID_IccPowerOn;
223:
224: typedef struct QEMU_PACKED CCID_IccPowerOff {
225: CCID_Header hdr;
226: uint16_t abRFU;
227: } CCID_IccPowerOff;
228:
229: typedef struct QEMU_PACKED CCID_SetParameters {
230: CCID_Header hdr;
231: uint8_t bProtocolNum;
232: uint16_t abRFU;
233: uint8_t abProtocolDataStructure[0];
234: } CCID_SetParameters;
235:
236: typedef struct CCID_Notify_Slot_Change {
237: uint8_t bMessageType; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
238: uint8_t bmSlotICCState;
239: } CCID_Notify_Slot_Change;
240:
241: /* used for DataBlock response to XferBlock */
242: typedef struct Answer {
243: uint8_t slot;
244: uint8_t seq;
245: } Answer;
246:
247: /* pending BULK_IN messages */
248: typedef struct BulkIn {
249: uint8_t data[BULK_IN_BUF_SIZE];
250: uint32_t len;
251: uint32_t pos;
252: } BulkIn;
253:
254: enum {
255: MIGRATION_NONE,
256: MIGRATION_MIGRATED,
257: };
258:
259: typedef struct CCIDBus {
260: BusState qbus;
261: } CCIDBus;
262:
263: #define MAX_PROTOCOL_SIZE 7
264:
265: /*
266: * powered - defaults to true, changed by PowerOn/PowerOff messages
267: */
268: typedef struct USBCCIDState {
269: USBDevice dev;
270: USBEndpoint *intr;
271: CCIDBus bus;
272: CCIDCardState *card;
273: BulkIn bulk_in_pending[BULK_IN_PENDING_NUM]; /* circular */
274: uint32_t bulk_in_pending_start;
275: uint32_t bulk_in_pending_end; /* first free */
276: uint32_t bulk_in_pending_num;
277: BulkIn *current_bulk_in;
278: uint8_t bulk_out_data[BULK_OUT_DATA_SIZE];
279: uint32_t bulk_out_pos;
280: uint64_t last_answer_error;
281: Answer pending_answers[PENDING_ANSWERS_NUM];
282: uint32_t pending_answers_start;
283: uint32_t pending_answers_end;
284: uint32_t pending_answers_num;
285: uint8_t bError;
286: uint8_t bmCommandStatus;
287: uint8_t bProtocolNum;
288: uint8_t abProtocolDataStructure[MAX_PROTOCOL_SIZE];
289: uint32_t ulProtocolDataStructureSize;
290: uint32_t state_vmstate;
291: uint32_t migration_target_ip;
292: uint16_t migration_target_port;
293: uint8_t migration_state;
294: uint8_t bmSlotICCState;
295: uint8_t powered;
296: uint8_t notify_slot_change;
297: uint8_t debug;
298: } USBCCIDState;
299:
300: /*
301: * CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
302: * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
303: * Specification.
304: *
305: * This device implemented based on the spec and with an Athena Smart Card
306: * Reader as reference:
307: * 0dc3:1004 Athena Smartcard Solutions, Inc.
308: */
309:
310: static const uint8_t qemu_ccid_descriptor[] = {
311: /* Smart Card Device Class Descriptor */
312: 0x36, /* u8 bLength; */
313: 0x21, /* u8 bDescriptorType; Functional */
314: 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
315: 0x00, /*
316: * u8 bMaxSlotIndex; The index of the highest available
317: * slot on this device. All slots are consecutive starting
318: * at 00h.
319: */
320: 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
321:
322: 0x03, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
323: 0x00, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
324: /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
325: 0xa0, 0x0f, 0x00, 0x00,
326: /* u32 dwMaximumClock; */
327: 0x00, 0x00, 0x01, 0x00,
328: 0x00, /* u8 bNumClockSupported; *
329: * 0 means just the default and max. */
330: /* u32 dwDataRate ;bps. 9600 == 00002580h */
331: 0x80, 0x25, 0x00, 0x00,
332: /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
333: 0x00, 0xC2, 0x01, 0x00,
334: 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
335: * default and max */
336: /* u32 dwMaxIFSD; *
337: * maximum IFSD supported by CCID for protocol *
338: * T=1 (Maximum seen from various cards) */
339: 0xfe, 0x00, 0x00, 0x00,
340: /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
341: 0x00, 0x00, 0x00, 0x00,
342: /* u32 dwMechanical; 0 - no special characteristics. */
343: 0x00, 0x00, 0x00, 0x00,
344: /*
345: * u32 dwFeatures;
346: * 0 - No special characteristics
347: * + 2 Automatic parameter configuration based on ATR data
348: * + 4 Automatic activation of ICC on inserting
349: * + 8 Automatic ICC voltage selection
350: * + 10 Automatic ICC clock frequency change
351: * + 20 Automatic baud rate change
352: * + 40 Automatic parameters negotiation made by the CCID
353: * + 80 automatic PPS made by the CCID
354: * 100 CCID can set ICC in clock stop mode
355: * 200 NAD value other then 00 accepted (T=1 protocol)
356: * + 400 Automatic IFSD exchange as first exchange (T=1)
357: * One of the following only:
358: * + 10000 TPDU level exchanges with CCID
359: * 20000 Short APDU level exchange with CCID
360: * 40000 Short and Extended APDU level exchange with CCID
361: *
362: * + 100000 USB Wake up signaling supported on card
363: * insertion and removal. Must set bit 5 in bmAttributes
364: * in Configuration descriptor if 100000 is set.
365: */
366: 0xfe, 0x04, 0x11, 0x00,
367: /*
368: * u32 dwMaxCCIDMessageLength; For extended APDU in
369: * [261 + 10 , 65544 + 10]. Otherwise the minimum is
370: * wMaxPacketSize of the Bulk-OUT endpoint
371: */
372: 0x12, 0x00, 0x01, 0x00,
373: 0xFF, /*
374: * u8 bClassGetResponse; Significant only for CCID that
375: * offers an APDU level for exchanges. Indicates the
376: * default class value used by the CCID when it sends a
377: * Get Response command to perform the transportation of
378: * an APDU by T=0 protocol
379: * FFh indicates that the CCID echos the class of the APDU.
380: */
381: 0xFF, /*
382: * u8 bClassEnvelope; EAPDU only. Envelope command for
383: * T=0
384: */
385: 0x00, 0x00, /*
386: * u16 wLcdLayout; XXYY Number of lines (XX) and chars per
387: * line for LCD display used for PIN entry. 0000 - no LCD
388: */
389: 0x01, /*
390: * u8 bPINSupport; 01h PIN Verification,
391: * 02h PIN Modification
392: */
393: 0x01, /* u8 bMaxCCIDBusySlots; */
394: };
395:
396: enum {
397: STR_MANUFACTURER = 1,
398: STR_PRODUCT,
399: STR_SERIALNUMBER,
400: STR_INTERFACE,
401: };
402:
403: static const USBDescStrings desc_strings = {
404: [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
405: [STR_PRODUCT] = "QEMU USB CCID",
406: [STR_SERIALNUMBER] = "1",
407: [STR_INTERFACE] = "CCID Interface",
408: };
409:
410: static const USBDescIface desc_iface0 = {
411: .bInterfaceNumber = 0,
412: .bNumEndpoints = 3,
413: .bInterfaceClass = 0x0b,
414: .bInterfaceSubClass = 0x00,
415: .bInterfaceProtocol = 0x00,
416: .iInterface = STR_INTERFACE,
417: .ndesc = 1,
418: .descs = (USBDescOther[]) {
419: {
420: /* smartcard descriptor */
421: .data = qemu_ccid_descriptor,
422: },
423: },
424: .eps = (USBDescEndpoint[]) {
425: {
426: .bEndpointAddress = USB_DIR_IN | CCID_INT_IN_EP,
427: .bmAttributes = USB_ENDPOINT_XFER_INT,
428: .bInterval = 255,
429: .wMaxPacketSize = 64,
430: },{
431: .bEndpointAddress = USB_DIR_IN | CCID_BULK_IN_EP,
432: .bmAttributes = USB_ENDPOINT_XFER_BULK,
433: .wMaxPacketSize = 64,
434: },{
435: .bEndpointAddress = USB_DIR_OUT | CCID_BULK_OUT_EP,
436: .bmAttributes = USB_ENDPOINT_XFER_BULK,
437: .wMaxPacketSize = 64,
438: },
439: }
440: };
441:
442: static const USBDescDevice desc_device = {
443: .bcdUSB = 0x0110,
444: .bMaxPacketSize0 = 64,
445: .bNumConfigurations = 1,
446: .confs = (USBDescConfig[]) {
447: {
448: .bNumInterfaces = 1,
449: .bConfigurationValue = 1,
450: .bmAttributes = 0xe0,
451: .bMaxPower = 50,
452: .nif = 1,
453: .ifs = &desc_iface0,
454: },
455: },
456: };
457:
458: static const USBDesc desc_ccid = {
459: .id = {
460: .idVendor = CCID_VENDOR_ID,
461: .idProduct = CCID_PRODUCT_ID,
462: .bcdDevice = CCID_DEVICE_VERSION,
463: .iManufacturer = STR_MANUFACTURER,
464: .iProduct = STR_PRODUCT,
465: .iSerialNumber = STR_SERIALNUMBER,
466: },
467: .full = &desc_device,
468: .str = desc_strings,
469: };
470:
471: static const uint8_t *ccid_card_get_atr(CCIDCardState *card, uint32_t *len)
472: {
473: CCIDCardClass *cc = CCID_CARD_GET_CLASS(card);
474: if (cc->get_atr) {
475: return cc->get_atr(card, len);
476: }
477: return NULL;
478: }
479:
480: static void ccid_card_apdu_from_guest(CCIDCardState *card,
481: const uint8_t *apdu,
482: uint32_t len)
483: {
484: CCIDCardClass *cc = CCID_CARD_GET_CLASS(card);
485: if (cc->apdu_from_guest) {
486: cc->apdu_from_guest(card, apdu, len);
487: }
488: }
489:
490: static int ccid_card_exitfn(CCIDCardState *card)
491: {
492: CCIDCardClass *cc = CCID_CARD_GET_CLASS(card);
493: if (cc->exitfn) {
494: return cc->exitfn(card);
495: }
496: return 0;
497: }
498:
499: static int ccid_card_initfn(CCIDCardState *card)
500: {
501: CCIDCardClass *cc = CCID_CARD_GET_CLASS(card);
502: if (cc->initfn) {
503: return cc->initfn(card);
504: }
505: return 0;
506: }
507:
508: static bool ccid_has_pending_answers(USBCCIDState *s)
509: {
510: return s->pending_answers_num > 0;
511: }
512:
513: static void ccid_clear_pending_answers(USBCCIDState *s)
514: {
515: s->pending_answers_num = 0;
516: s->pending_answers_start = 0;
517: s->pending_answers_end = 0;
518: }
519:
520: static void ccid_print_pending_answers(USBCCIDState *s)
521: {
522: Answer *answer;
523: int i, count;
524:
525: DPRINTF(s, D_VERBOSE, "usb-ccid: pending answers:");
526: if (!ccid_has_pending_answers(s)) {
527: DPRINTF(s, D_VERBOSE, " empty\n");
528: return;
529: }
530: for (i = s->pending_answers_start, count = s->pending_answers_num ;
531: count > 0; count--, i++) {
532: answer = &s->pending_answers[i % PENDING_ANSWERS_NUM];
533: if (count == 1) {
534: DPRINTF(s, D_VERBOSE, "%d:%d\n", answer->slot, answer->seq);
535: } else {
536: DPRINTF(s, D_VERBOSE, "%d:%d,", answer->slot, answer->seq);
537: }
538: }
539: }
540:
541: static void ccid_add_pending_answer(USBCCIDState *s, CCID_Header *hdr)
542: {
543: Answer *answer;
544:
545: assert(s->pending_answers_num < PENDING_ANSWERS_NUM);
546: s->pending_answers_num++;
547: answer =
548: &s->pending_answers[(s->pending_answers_end++) % PENDING_ANSWERS_NUM];
549: answer->slot = hdr->bSlot;
550: answer->seq = hdr->bSeq;
551: ccid_print_pending_answers(s);
552: }
553:
554: static void ccid_remove_pending_answer(USBCCIDState *s,
555: uint8_t *slot, uint8_t *seq)
556: {
557: Answer *answer;
558:
559: assert(s->pending_answers_num > 0);
560: s->pending_answers_num--;
561: answer =
562: &s->pending_answers[(s->pending_answers_start++) % PENDING_ANSWERS_NUM];
563: *slot = answer->slot;
564: *seq = answer->seq;
565: ccid_print_pending_answers(s);
566: }
567:
568: static void ccid_bulk_in_clear(USBCCIDState *s)
569: {
570: s->bulk_in_pending_start = 0;
571: s->bulk_in_pending_end = 0;
572: s->bulk_in_pending_num = 0;
573: }
574:
575: static void ccid_bulk_in_release(USBCCIDState *s)
576: {
577: assert(s->current_bulk_in != NULL);
578: s->current_bulk_in->pos = 0;
579: s->current_bulk_in = NULL;
580: }
581:
582: static void ccid_bulk_in_get(USBCCIDState *s)
583: {
584: if (s->current_bulk_in != NULL || s->bulk_in_pending_num == 0) {
585: return;
586: }
587: assert(s->bulk_in_pending_num > 0);
588: s->bulk_in_pending_num--;
589: s->current_bulk_in =
590: &s->bulk_in_pending[(s->bulk_in_pending_start++) % BULK_IN_PENDING_NUM];
591: }
592:
593: static void *ccid_reserve_recv_buf(USBCCIDState *s, uint16_t len)
594: {
595: BulkIn *bulk_in;
596:
597: DPRINTF(s, D_VERBOSE, "%s: QUEUE: reserve %d bytes\n", __func__, len);
598:
599: /* look for an existing element */
600: if (len > BULK_IN_BUF_SIZE) {
601: DPRINTF(s, D_WARN, "usb-ccid.c: %s: len larger then max (%d>%d). "
602: "discarding message.\n",
603: __func__, len, BULK_IN_BUF_SIZE);
604: return NULL;
605: }
606: if (s->bulk_in_pending_num >= BULK_IN_PENDING_NUM) {
607: DPRINTF(s, D_WARN, "usb-ccid.c: %s: No free bulk_in buffers. "
608: "discarding message.\n", __func__);
609: return NULL;
610: }
611: bulk_in =
612: &s->bulk_in_pending[(s->bulk_in_pending_end++) % BULK_IN_PENDING_NUM];
613: s->bulk_in_pending_num++;
614: bulk_in->len = len;
615: return bulk_in->data;
616: }
617:
618: static void ccid_reset(USBCCIDState *s)
619: {
620: ccid_bulk_in_clear(s);
621: ccid_clear_pending_answers(s);
622: }
623:
624: static void ccid_detach(USBCCIDState *s)
625: {
626: ccid_reset(s);
627: }
628:
629: static void ccid_handle_reset(USBDevice *dev)
630: {
631: USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
632:
633: DPRINTF(s, 1, "Reset\n");
634:
635: ccid_reset(s);
636: }
637:
638: static int ccid_handle_control(USBDevice *dev, USBPacket *p, int request,
639: int value, int index, int length, uint8_t *data)
640: {
641: USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
642: int ret = 0;
643:
644: DPRINTF(s, 1, "got control %x, value %x\n", request, value);
645: ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
646: if (ret >= 0) {
647: return ret;
648: }
649:
650: switch (request) {
651: /* Class specific requests. */
652: case InterfaceOutClass | CCID_CONTROL_ABORT:
653: DPRINTF(s, 1, "ccid_control abort UNIMPLEMENTED\n");
654: ret = USB_RET_STALL;
655: break;
656: case InterfaceInClass | CCID_CONTROL_GET_CLOCK_FREQUENCIES:
657: DPRINTF(s, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
658: ret = USB_RET_STALL;
659: break;
660: case InterfaceInClass | CCID_CONTROL_GET_DATA_RATES:
661: DPRINTF(s, 1, "ccid_control get data rates UNIMPLEMENTED\n");
662: ret = USB_RET_STALL;
663: break;
664: default:
665: DPRINTF(s, 1, "got unsupported/bogus control %x, value %x\n",
666: request, value);
667: ret = USB_RET_STALL;
668: break;
669: }
670: return ret;
671: }
672:
673: static bool ccid_card_inserted(USBCCIDState *s)
674: {
675: return s->bmSlotICCState & SLOT_0_STATE_MASK;
676: }
677:
678: static uint8_t ccid_card_status(USBCCIDState *s)
679: {
680: return ccid_card_inserted(s)
681: ? (s->powered ?
682: ICC_STATUS_PRESENT_ACTIVE
683: : ICC_STATUS_PRESENT_INACTIVE
684: )
685: : ICC_STATUS_NOT_PRESENT;
686: }
687:
688: static uint8_t ccid_calc_status(USBCCIDState *s)
689: {
690: /*
691: * page 55, 6.2.6, calculation of bStatus from bmICCStatus and
692: * bmCommandStatus
693: */
694: uint8_t ret = ccid_card_status(s) | (s->bmCommandStatus << 6);
695: DPRINTF(s, D_VERBOSE, "status = %d\n", ret);
696: return ret;
697: }
698:
699: static void ccid_reset_error_status(USBCCIDState *s)
700: {
701: s->bError = ERROR_CMD_NOT_SUPPORTED;
702: s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
703: }
704:
705: static void ccid_write_slot_status(USBCCIDState *s, CCID_Header *recv)
706: {
707: CCID_SlotStatus *h = ccid_reserve_recv_buf(s, sizeof(CCID_SlotStatus));
708: if (h == NULL) {
709: return;
710: }
711: h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus;
712: h->b.hdr.dwLength = 0;
713: h->b.hdr.bSlot = recv->bSlot;
714: h->b.hdr.bSeq = recv->bSeq;
715: h->b.bStatus = ccid_calc_status(s);
716: h->b.bError = s->bError;
717: h->bClockStatus = CLOCK_STATUS_RUNNING;
718: ccid_reset_error_status(s);
719: }
720:
721: static void ccid_write_parameters(USBCCIDState *s, CCID_Header *recv)
722: {
723: CCID_Parameter *h;
724: uint32_t len = s->ulProtocolDataStructureSize;
725:
726: h = ccid_reserve_recv_buf(s, sizeof(CCID_Parameter) + len);
727: if (h == NULL) {
728: return;
729: }
730: h->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_Parameters;
731: h->b.hdr.dwLength = 0;
732: h->b.hdr.bSlot = recv->bSlot;
733: h->b.hdr.bSeq = recv->bSeq;
734: h->b.bStatus = ccid_calc_status(s);
735: h->b.bError = s->bError;
736: h->bProtocolNum = s->bProtocolNum;
737: memcpy(h->abProtocolDataStructure, s->abProtocolDataStructure, len);
738: ccid_reset_error_status(s);
739: }
740:
741: static void ccid_write_data_block(USBCCIDState *s, uint8_t slot, uint8_t seq,
742: const uint8_t *data, uint32_t len)
743: {
744: CCID_DataBlock *p = ccid_reserve_recv_buf(s, sizeof(*p) + len);
745:
746: if (p == NULL) {
747: return;
748: }
749: p->b.hdr.bMessageType = CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock;
750: p->b.hdr.dwLength = cpu_to_le32(len);
751: p->b.hdr.bSlot = slot;
752: p->b.hdr.bSeq = seq;
753: p->b.bStatus = ccid_calc_status(s);
754: p->b.bError = s->bError;
755: if (p->b.bError) {
756: DPRINTF(s, D_VERBOSE, "error %d", p->b.bError);
757: }
758: memcpy(p->abData, data, len);
759: ccid_reset_error_status(s);
760: }
761:
762: static void ccid_write_data_block_answer(USBCCIDState *s,
763: const uint8_t *data, uint32_t len)
764: {
765: uint8_t seq;
766: uint8_t slot;
767:
768: if (!ccid_has_pending_answers(s)) {
769: abort();
770: }
771: ccid_remove_pending_answer(s, &slot, &seq);
772: ccid_write_data_block(s, slot, seq, data, len);
773: }
774:
775: static void ccid_write_data_block_atr(USBCCIDState *s, CCID_Header *recv)
776: {
777: const uint8_t *atr = NULL;
778: uint32_t len = 0;
779:
780: if (s->card) {
781: atr = ccid_card_get_atr(s->card, &len);
782: }
783: ccid_write_data_block(s, recv->bSlot, recv->bSeq, atr, len);
784: }
785:
786: static void ccid_set_parameters(USBCCIDState *s, CCID_Header *recv)
787: {
788: CCID_SetParameters *ph = (CCID_SetParameters *) recv;
789: uint32_t len = 0;
790: if ((ph->bProtocolNum & 3) == 0) {
791: len = 5;
792: }
793: if ((ph->bProtocolNum & 3) == 1) {
794: len = 7;
795: }
796: if (len == 0) {
797: s->bmCommandStatus = COMMAND_STATUS_FAILED;
798: s->bError = 7; /* Protocol invalid or not supported */
799: return;
800: }
801: s->bProtocolNum = ph->bProtocolNum;
802: memcpy(s->abProtocolDataStructure, ph->abProtocolDataStructure, len);
803: s->ulProtocolDataStructureSize = len;
804: DPRINTF(s, 1, "%s: using len %d\n", __func__, len);
805: }
806:
807: /*
808: * must be 5 bytes for T=0, 7 bytes for T=1
809: * See page 52
810: */
811: static const uint8_t abDefaultProtocolDataStructure[7] = {
812: 0x77, 0x00, 0x00, 0x00, 0x00, 0xfe /*IFSC*/, 0x00 /*NAD*/ };
813:
814: static void ccid_reset_parameters(USBCCIDState *s)
815: {
816: uint32_t len = sizeof(abDefaultProtocolDataStructure);
817:
818: s->bProtocolNum = 1; /* T=1 */
819: s->ulProtocolDataStructureSize = len;
820: memcpy(s->abProtocolDataStructure, abDefaultProtocolDataStructure, len);
821: }
822:
823: static void ccid_report_error_failed(USBCCIDState *s, uint8_t error)
824: {
825: s->bmCommandStatus = COMMAND_STATUS_FAILED;
826: s->bError = error;
827: }
828:
829: /* NOTE: only a single slot is supported (SLOT_0) */
830: static void ccid_on_slot_change(USBCCIDState *s, bool full)
831: {
832: /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56 */
833: uint8_t current = s->bmSlotICCState;
834: if (full) {
835: s->bmSlotICCState |= SLOT_0_STATE_MASK;
836: } else {
837: s->bmSlotICCState &= ~SLOT_0_STATE_MASK;
838: }
839: if (current != s->bmSlotICCState) {
840: s->bmSlotICCState |= SLOT_0_CHANGED_MASK;
841: }
842: s->notify_slot_change = true;
843: usb_wakeup(s->intr);
844: }
845:
846: static void ccid_write_data_block_error(
847: USBCCIDState *s, uint8_t slot, uint8_t seq)
848: {
849: ccid_write_data_block(s, slot, seq, NULL, 0);
850: }
851:
852: static void ccid_on_apdu_from_guest(USBCCIDState *s, CCID_XferBlock *recv)
853: {
854: uint32_t len;
855:
856: if (ccid_card_status(s) != ICC_STATUS_PRESENT_ACTIVE) {
857: DPRINTF(s, 1,
858: "usb-ccid: not sending apdu to client, no card connected\n");
859: ccid_write_data_block_error(s, recv->hdr.bSlot, recv->hdr.bSeq);
860: return;
861: }
862: len = le32_to_cpu(recv->hdr.dwLength);
863: DPRINTF(s, 1, "%s: seq %d, len %d\n", __func__,
864: recv->hdr.bSeq, len);
865: ccid_add_pending_answer(s, (CCID_Header *)recv);
866: if (s->card) {
867: ccid_card_apdu_from_guest(s->card, recv->abData, len);
868: } else {
869: DPRINTF(s, D_WARN, "warning: discarded apdu\n");
870: }
871: }
872:
873: /*
874: * Handle a single USB_TOKEN_OUT, return value returned to guest.
875: * Return value:
876: * 0 - all ok
877: * USB_RET_STALL - failed to handle packet
878: */
879: static int ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p)
880: {
881: CCID_Header *ccid_header;
882:
883: if (p->iov.size + s->bulk_out_pos > BULK_OUT_DATA_SIZE) {
884: return USB_RET_STALL;
885: }
886: ccid_header = (CCID_Header *)s->bulk_out_data;
887: usb_packet_copy(p, s->bulk_out_data + s->bulk_out_pos, p->iov.size);
888: s->bulk_out_pos += p->iov.size;
889: if (p->iov.size == CCID_MAX_PACKET_SIZE) {
890: DPRINTF(s, D_VERBOSE,
891: "usb-ccid: bulk_in: expecting more packets (%zd/%d)\n",
892: p->iov.size, ccid_header->dwLength);
893: return 0;
894: }
895: if (s->bulk_out_pos < 10) {
896: DPRINTF(s, 1,
897: "%s: bad USB_TOKEN_OUT length, should be at least 10 bytes\n",
898: __func__);
899: } else {
900: DPRINTF(s, D_MORE_INFO, "%s %x\n", __func__, ccid_header->bMessageType);
901: switch (ccid_header->bMessageType) {
902: case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus:
903: ccid_write_slot_status(s, ccid_header);
904: break;
905: case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn:
906: DPRINTF(s, 1, "PowerOn: %d\n",
907: ((CCID_IccPowerOn *)(ccid_header))->bPowerSelect);
908: s->powered = true;
909: if (!ccid_card_inserted(s)) {
910: ccid_report_error_failed(s, ERROR_ICC_MUTE);
911: }
912: /* atr is written regardless of error. */
913: ccid_write_data_block_atr(s, ccid_header);
914: break;
915: case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff:
916: DPRINTF(s, 1, "PowerOff\n");
917: ccid_reset_error_status(s);
918: s->powered = false;
919: ccid_write_slot_status(s, ccid_header);
920: break;
921: case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock:
922: ccid_on_apdu_from_guest(s, (CCID_XferBlock *)s->bulk_out_data);
923: break;
924: case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters:
925: ccid_reset_error_status(s);
926: ccid_set_parameters(s, ccid_header);
927: ccid_write_parameters(s, ccid_header);
928: break;
929: case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters:
930: ccid_reset_error_status(s);
931: ccid_reset_parameters(s);
932: ccid_write_parameters(s, ccid_header);
933: break;
934: case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters:
935: ccid_reset_error_status(s);
936: ccid_write_parameters(s, ccid_header);
937: break;
938: default:
939: DPRINTF(s, 1,
940: "handle_data: ERROR: unhandled message type %Xh\n",
941: ccid_header->bMessageType);
942: /*
943: * The caller is expecting the device to respond, tell it we
944: * don't support the operation.
945: */
946: ccid_report_error_failed(s, ERROR_CMD_NOT_SUPPORTED);
947: ccid_write_slot_status(s, ccid_header);
948: break;
949: }
950: }
951: s->bulk_out_pos = 0;
952: return 0;
953: }
954:
955: static int ccid_bulk_in_copy_to_guest(USBCCIDState *s, USBPacket *p)
956: {
957: int ret = 0;
958:
959: assert(p->iov.size > 0);
960: ccid_bulk_in_get(s);
961: if (s->current_bulk_in != NULL) {
962: ret = MIN(s->current_bulk_in->len - s->current_bulk_in->pos,
963: p->iov.size);
964: usb_packet_copy(p, s->current_bulk_in->data +
965: s->current_bulk_in->pos, ret);
966: s->current_bulk_in->pos += ret;
967: if (s->current_bulk_in->pos == s->current_bulk_in->len) {
968: ccid_bulk_in_release(s);
969: }
970: } else {
971: /* return when device has no data - usb 2.0 spec Table 8-4 */
972: ret = USB_RET_NAK;
973: }
974: if (ret > 0) {
975: DPRINTF(s, D_MORE_INFO,
976: "%s: %zd/%d req/act to guest (BULK_IN)\n",
977: __func__, p->iov.size, ret);
978: }
979: if (ret != USB_RET_NAK && ret < p->iov.size) {
980: DPRINTF(s, 1,
981: "%s: returning short (EREMOTEIO) %d < %zd\n",
982: __func__, ret, p->iov.size);
983: }
984: return ret;
985: }
986:
987: static int ccid_handle_data(USBDevice *dev, USBPacket *p)
988: {
989: USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
990: int ret = 0;
991: uint8_t buf[2];
992:
993: switch (p->pid) {
994: case USB_TOKEN_OUT:
995: ret = ccid_handle_bulk_out(s, p);
996: break;
997:
998: case USB_TOKEN_IN:
999: switch (p->ep->nr) {
1000: case CCID_BULK_IN_EP:
1001: if (!p->iov.size) {
1002: ret = USB_RET_NAK;
1003: } else {
1004: ret = ccid_bulk_in_copy_to_guest(s, p);
1005: }
1006: break;
1007: case CCID_INT_IN_EP:
1008: if (s->notify_slot_change) {
1009: /* page 56, RDR_to_PC_NotifySlotChange */
1010: buf[0] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange;
1011: buf[1] = s->bmSlotICCState;
1012: usb_packet_copy(p, buf, 2);
1013: ret = 2;
1014: s->notify_slot_change = false;
1015: s->bmSlotICCState &= ~SLOT_0_CHANGED_MASK;
1016: DPRINTF(s, D_INFO,
1017: "handle_data: int_in: notify_slot_change %X, "
1018: "requested len %zd\n",
1019: s->bmSlotICCState, p->iov.size);
1020: }
1021: break;
1022: default:
1023: DPRINTF(s, 1, "Bad endpoint\n");
1024: ret = USB_RET_STALL;
1025: break;
1026: }
1027: break;
1028: default:
1029: DPRINTF(s, 1, "Bad token\n");
1030: ret = USB_RET_STALL;
1031: break;
1032: }
1033:
1034: return ret;
1035: }
1036:
1037: static void ccid_handle_destroy(USBDevice *dev)
1038: {
1039: USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
1040:
1041: ccid_bulk_in_clear(s);
1042: }
1043:
1044: static void ccid_flush_pending_answers(USBCCIDState *s)
1045: {
1046: while (ccid_has_pending_answers(s)) {
1047: ccid_write_data_block_answer(s, NULL, 0);
1048: }
1049: }
1050:
1051: static Answer *ccid_peek_next_answer(USBCCIDState *s)
1052: {
1053: return s->pending_answers_num == 0
1054: ? NULL
1055: : &s->pending_answers[s->pending_answers_start % PENDING_ANSWERS_NUM];
1056: }
1057:
1058: static struct BusInfo ccid_bus_info = {
1059: .name = "ccid-bus",
1060: .size = sizeof(CCIDBus),
1061: .props = (Property[]) {
1062: DEFINE_PROP_UINT32("slot", struct CCIDCardState, slot, 0),
1063: DEFINE_PROP_END_OF_LIST(),
1064: }
1065: };
1066:
1067: void ccid_card_send_apdu_to_guest(CCIDCardState *card,
1068: uint8_t *apdu, uint32_t len)
1069: {
1070: USBCCIDState *s = DO_UPCAST(USBCCIDState, dev.qdev,
1071: card->qdev.parent_bus->parent);
1072: Answer *answer;
1073:
1074: if (!ccid_has_pending_answers(s)) {
1075: DPRINTF(s, 1, "CCID ERROR: got an APDU without pending answers\n");
1076: return;
1077: }
1078: s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
1079: answer = ccid_peek_next_answer(s);
1080: if (answer == NULL) {
1081: abort();
1082: }
1083: DPRINTF(s, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
1084: len, answer->seq, answer->slot);
1085: ccid_write_data_block_answer(s, apdu, len);
1086: }
1087:
1088: void ccid_card_card_removed(CCIDCardState *card)
1089: {
1090: USBCCIDState *s =
1091: DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
1092:
1093: ccid_on_slot_change(s, false);
1094: ccid_flush_pending_answers(s);
1095: ccid_reset(s);
1096: }
1097:
1098: int ccid_card_ccid_attach(CCIDCardState *card)
1099: {
1100: USBCCIDState *s =
1101: DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
1102:
1103: DPRINTF(s, 1, "CCID Attach\n");
1104: if (s->migration_state == MIGRATION_MIGRATED) {
1105: s->migration_state = MIGRATION_NONE;
1106: }
1107: return 0;
1108: }
1109:
1110: void ccid_card_ccid_detach(CCIDCardState *card)
1111: {
1112: USBCCIDState *s =
1113: DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
1114:
1115: DPRINTF(s, 1, "CCID Detach\n");
1116: if (ccid_card_inserted(s)) {
1117: ccid_on_slot_change(s, false);
1118: }
1119: ccid_detach(s);
1120: }
1121:
1122: void ccid_card_card_error(CCIDCardState *card, uint64_t error)
1123: {
1124: USBCCIDState *s =
1125: DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
1126:
1127: s->bmCommandStatus = COMMAND_STATUS_FAILED;
1128: s->last_answer_error = error;
1129: DPRINTF(s, 1, "VSC_Error: %" PRIX64 "\n", s->last_answer_error);
1130: /* TODO: these errors should be more verbose and propagated to the guest.*/
1131: /*
1132: * We flush all pending answers on CardRemove message in ccid-card-passthru,
1133: * so check that first to not trigger abort
1134: */
1135: if (ccid_has_pending_answers(s)) {
1136: ccid_write_data_block_answer(s, NULL, 0);
1137: }
1138: }
1139:
1140: void ccid_card_card_inserted(CCIDCardState *card)
1141: {
1142: USBCCIDState *s =
1143: DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
1144:
1145: s->bmCommandStatus = COMMAND_STATUS_NO_ERROR;
1146: ccid_flush_pending_answers(s);
1147: ccid_on_slot_change(s, true);
1148: }
1149:
1150: static int ccid_card_exit(DeviceState *qdev)
1151: {
1152: int ret = 0;
1153: CCIDCardState *card = CCID_CARD(qdev);
1154: USBCCIDState *s =
1155: DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
1156:
1157: if (ccid_card_inserted(s)) {
1158: ccid_card_card_removed(card);
1159: }
1160: ret = ccid_card_exitfn(card);
1161: s->card = NULL;
1162: return ret;
1163: }
1164:
1165: static int ccid_card_init(DeviceState *qdev)
1166: {
1167: CCIDCardState *card = CCID_CARD(qdev);
1168: USBCCIDState *s =
1169: DO_UPCAST(USBCCIDState, dev.qdev, card->qdev.parent_bus->parent);
1170: int ret = 0;
1171:
1172: if (card->slot != 0) {
1173: error_report("Warning: usb-ccid supports one slot, can't add %d",
1174: card->slot);
1175: return -1;
1176: }
1177: if (s->card != NULL) {
1178: error_report("Warning: usb-ccid card already full, not adding");
1179: return -1;
1180: }
1181: ret = ccid_card_initfn(card);
1182: if (ret == 0) {
1183: s->card = card;
1184: }
1185: return ret;
1186: }
1187:
1188: static int ccid_initfn(USBDevice *dev)
1189: {
1190: USBCCIDState *s = DO_UPCAST(USBCCIDState, dev, dev);
1191:
1192: usb_desc_create_serial(dev);
1193: usb_desc_init(dev);
1194: qbus_create_inplace(&s->bus.qbus, &ccid_bus_info, &dev->qdev, NULL);
1195: s->intr = usb_ep_get(dev, USB_TOKEN_IN, CCID_INT_IN_EP);
1196: s->bus.qbus.allow_hotplug = 1;
1197: s->card = NULL;
1198: s->migration_state = MIGRATION_NONE;
1199: s->migration_target_ip = 0;
1200: s->migration_target_port = 0;
1201: s->dev.speed = USB_SPEED_FULL;
1202: s->dev.speedmask = USB_SPEED_MASK_FULL;
1203: s->notify_slot_change = false;
1204: s->powered = true;
1205: s->pending_answers_num = 0;
1206: s->last_answer_error = 0;
1207: s->bulk_in_pending_start = 0;
1208: s->bulk_in_pending_end = 0;
1209: s->current_bulk_in = NULL;
1210: ccid_reset_error_status(s);
1211: s->bulk_out_pos = 0;
1212: ccid_reset_parameters(s);
1213: ccid_reset(s);
1214: return 0;
1215: }
1216:
1217: static int ccid_post_load(void *opaque, int version_id)
1218: {
1219: USBCCIDState *s = opaque;
1220:
1221: /*
1222: * This must be done after usb_device_attach, which sets state to ATTACHED,
1223: * while it must be DEFAULT in order to accept packets (like it is after
1224: * reset, but reset will reset our addr and call our reset handler which
1225: * may change state, and we don't want to do that when migrating).
1226: */
1227: s->dev.state = s->state_vmstate;
1228: return 0;
1229: }
1230:
1231: static void ccid_pre_save(void *opaque)
1232: {
1233: USBCCIDState *s = opaque;
1234:
1235: s->state_vmstate = s->dev.state;
1236: if (s->dev.attached) {
1237: /*
1238: * Migrating an open device, ignore reconnection CHR_EVENT to avoid an
1239: * erroneous detach.
1240: */
1241: s->migration_state = MIGRATION_MIGRATED;
1242: }
1243: }
1244:
1245: static VMStateDescription bulk_in_vmstate = {
1246: .name = "CCID BulkIn state",
1247: .version_id = 1,
1248: .minimum_version_id = 1,
1249: .fields = (VMStateField[]) {
1250: VMSTATE_BUFFER(data, BulkIn),
1251: VMSTATE_UINT32(len, BulkIn),
1252: VMSTATE_UINT32(pos, BulkIn),
1253: VMSTATE_END_OF_LIST()
1254: }
1255: };
1256:
1257: static VMStateDescription answer_vmstate = {
1258: .name = "CCID Answer state",
1259: .version_id = 1,
1260: .minimum_version_id = 1,
1261: .fields = (VMStateField[]) {
1262: VMSTATE_UINT8(slot, Answer),
1263: VMSTATE_UINT8(seq, Answer),
1264: VMSTATE_END_OF_LIST()
1265: }
1266: };
1267:
1268: static VMStateDescription usb_device_vmstate = {
1269: .name = "usb_device",
1270: .version_id = 1,
1271: .minimum_version_id = 1,
1272: .fields = (VMStateField[]) {
1273: VMSTATE_UINT8(addr, USBDevice),
1274: VMSTATE_BUFFER(setup_buf, USBDevice),
1275: VMSTATE_BUFFER(data_buf, USBDevice),
1276: VMSTATE_END_OF_LIST()
1277: }
1278: };
1279:
1280: static VMStateDescription ccid_vmstate = {
1281: .name = CCID_DEV_NAME,
1282: .version_id = 1,
1283: .minimum_version_id = 1,
1284: .post_load = ccid_post_load,
1285: .pre_save = ccid_pre_save,
1286: .fields = (VMStateField[]) {
1287: VMSTATE_STRUCT(dev, USBCCIDState, 1, usb_device_vmstate, USBDevice),
1288: VMSTATE_UINT8(debug, USBCCIDState),
1289: VMSTATE_BUFFER(bulk_out_data, USBCCIDState),
1290: VMSTATE_UINT32(bulk_out_pos, USBCCIDState),
1291: VMSTATE_UINT8(bmSlotICCState, USBCCIDState),
1292: VMSTATE_UINT8(powered, USBCCIDState),
1293: VMSTATE_UINT8(notify_slot_change, USBCCIDState),
1294: VMSTATE_UINT64(last_answer_error, USBCCIDState),
1295: VMSTATE_UINT8(bError, USBCCIDState),
1296: VMSTATE_UINT8(bmCommandStatus, USBCCIDState),
1297: VMSTATE_UINT8(bProtocolNum, USBCCIDState),
1298: VMSTATE_BUFFER(abProtocolDataStructure, USBCCIDState),
1299: VMSTATE_UINT32(ulProtocolDataStructureSize, USBCCIDState),
1300: VMSTATE_STRUCT_ARRAY(bulk_in_pending, USBCCIDState,
1301: BULK_IN_PENDING_NUM, 1, bulk_in_vmstate, BulkIn),
1302: VMSTATE_UINT32(bulk_in_pending_start, USBCCIDState),
1303: VMSTATE_UINT32(bulk_in_pending_end, USBCCIDState),
1304: VMSTATE_STRUCT_ARRAY(pending_answers, USBCCIDState,
1305: PENDING_ANSWERS_NUM, 1, answer_vmstate, Answer),
1306: VMSTATE_UINT32(pending_answers_num, USBCCIDState),
1307: VMSTATE_UINT8(migration_state, USBCCIDState),
1308: VMSTATE_UINT32(state_vmstate, USBCCIDState),
1309: VMSTATE_END_OF_LIST()
1310: }
1311: };
1312:
1313: static Property ccid_properties[] = {
1314: DEFINE_PROP_UINT8("debug", USBCCIDState, debug, 0),
1315: DEFINE_PROP_END_OF_LIST(),
1316: };
1317:
1318: static void ccid_class_initfn(ObjectClass *klass, void *data)
1319: {
1320: DeviceClass *dc = DEVICE_CLASS(klass);
1321: USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
1322:
1323: uc->init = ccid_initfn;
1324: uc->product_desc = "QEMU USB CCID";
1325: uc->usb_desc = &desc_ccid;
1326: uc->handle_reset = ccid_handle_reset;
1327: uc->handle_control = ccid_handle_control;
1328: uc->handle_data = ccid_handle_data;
1329: uc->handle_destroy = ccid_handle_destroy;
1330: dc->desc = "CCID Rev 1.1 smartcard reader";
1331: dc->vmsd = &ccid_vmstate;
1332: dc->props = ccid_properties;
1333: }
1334:
1335: static TypeInfo ccid_info = {
1336: .name = CCID_DEV_NAME,
1337: .parent = TYPE_USB_DEVICE,
1338: .instance_size = sizeof(USBCCIDState),
1339: .class_init = ccid_class_initfn,
1340: };
1341:
1342: static void ccid_card_class_init(ObjectClass *klass, void *data)
1343: {
1344: DeviceClass *k = DEVICE_CLASS(klass);
1345: k->bus_info = &ccid_bus_info;
1346: k->init = ccid_card_init;
1347: k->exit = ccid_card_exit;
1348: }
1349:
1350: static TypeInfo ccid_card_type_info = {
1351: .name = TYPE_CCID_CARD,
1352: .parent = TYPE_DEVICE,
1353: .instance_size = sizeof(CCIDCardState),
1354: .abstract = true,
1355: .class_size = sizeof(CCIDCardClass),
1356: .class_init = ccid_card_class_init,
1357: };
1358:
1359: static void ccid_register_types(void)
1360: {
1361: type_register_static(&ccid_card_type_info);
1362: type_register_static(&ccid_info);
1363: usb_legacy_register(CCID_DEV_NAME, "ccid", NULL);
1364: }
1365:
1366: type_init(ccid_register_types)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.