2 * Copyright (C) 2011 Red Hat, Inc.
4 * CCID Device emulation
6 * Written by Alon Levy, with contributions from Robert Relyea.
8 * Based on usb-serial.c, see its copyright and attributions below.
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 <samuel.thibault@ens-lyon.org>
15 * Written by Paul Brook, reused for FTDI by Samuel Thibault,
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
25 * Endianness note: from the spec (1.3)
26 * "Fields that are larger than a byte are stored in little endian"
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.
37 #include "qemu/osdep.h"
38 #include "qapi/error.h"
39 #include "qemu-common.h"
40 #include "qemu/error-report.h"
42 #include "hw/usb/desc.h"
46 #define DPRINTF(s, lvl, fmt, ...) \
48 if (lvl <= s->debug) { \
49 printf("usb-ccid: " fmt , ## __VA_ARGS__); \
58 #define CCID_DEV_NAME "usb-ccid"
59 #define USB_CCID_DEV(obj) OBJECT_CHECK(USBCCIDState, (obj), CCID_DEV_NAME)
61 * The two options for variable sized buffers:
62 * make them constant size, for large enough constant,
63 * or handle the migration complexity - VMState doesn't handle this case.
64 * sizes are expected never to be exceeded, unless guest misbehaves.
66 #define BULK_OUT_DATA_SIZE 65536
67 #define PENDING_ANSWERS_NUM 128
69 #define BULK_IN_BUF_SIZE 384
70 #define BULK_IN_PENDING_NUM 8
72 #define CCID_MAX_PACKET_SIZE 64
74 #define CCID_CONTROL_ABORT 0x1
75 #define CCID_CONTROL_GET_CLOCK_FREQUENCIES 0x2
76 #define CCID_CONTROL_GET_DATA_RATES 0x3
78 #define CCID_PRODUCT_DESCRIPTION "QEMU USB CCID"
79 #define CCID_VENDOR_DESCRIPTION "QEMU"
80 #define CCID_INTERFACE_NAME "CCID Interface"
81 #define CCID_SERIAL_NUMBER_STRING "1"
83 * Using Gemplus Vendor and Product id
84 * Effect on various drivers:
85 * usbccid.sys (winxp, others untested) is a class driver so it doesn't care.
86 * linux has a number of class drivers, but openct filters based on
87 * vendor/product (/etc/openct.conf under fedora), hence Gemplus.
89 #define CCID_VENDOR_ID 0x08e6
90 #define CCID_PRODUCT_ID 0x4433
91 #define CCID_DEVICE_VERSION 0x0000
94 * BULK_OUT messages from PC to Reader
95 * Defined in CCID Rev 1.1 6.1 (page 26)
97 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn 0x62
98 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff 0x63
99 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus 0x65
100 #define CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock 0x6f
101 #define CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters 0x6c
102 #define CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters 0x6d
103 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters 0x61
104 #define CCID_MESSAGE_TYPE_PC_to_RDR_Escape 0x6b
105 #define CCID_MESSAGE_TYPE_PC_to_RDR_IccClock 0x6e
106 #define CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU 0x6a
107 #define CCID_MESSAGE_TYPE_PC_to_RDR_Secure 0x69
108 #define CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical 0x71
109 #define CCID_MESSAGE_TYPE_PC_to_RDR_Abort 0x72
110 #define CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency 0x73
113 * BULK_IN messages from Reader to PC
114 * Defined in CCID Rev 1.1 6.2 (page 48)
116 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock 0x80
117 #define CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus 0x81
118 #define CCID_MESSAGE_TYPE_RDR_to_PC_Parameters 0x82
119 #define CCID_MESSAGE_TYPE_RDR_to_PC_Escape 0x83
120 #define CCID_MESSAGE_TYPE_RDR_to_PC_DataRateAndClockFrequency 0x84
123 * INTERRUPT_IN messages from Reader to PC
124 * Defined in CCID Rev 1.1 6.3 (page 56)
126 #define CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange 0x50
127 #define CCID_MESSAGE_TYPE_RDR_to_PC_HardwareError 0x51
130 * Endpoints for CCID - addresses are up to us to decide.
131 * To support slot insertion and removal we must have an interrupt in ep
132 * in addition we need a bulk in and bulk out ep
135 #define CCID_INT_IN_EP 1
136 #define CCID_BULK_IN_EP 2
137 #define CCID_BULK_OUT_EP 3
139 /* bmSlotICCState masks */
140 #define SLOT_0_STATE_MASK 1
141 #define SLOT_0_CHANGED_MASK 2
143 /* Status codes that go in bStatus (see 6.2.6) */
145 ICC_STATUS_PRESENT_ACTIVE
= 0,
146 ICC_STATUS_PRESENT_INACTIVE
,
147 ICC_STATUS_NOT_PRESENT
151 COMMAND_STATUS_NO_ERROR
= 0,
152 COMMAND_STATUS_FAILED
,
153 COMMAND_STATUS_TIME_EXTENSION_REQUIRED
156 /* Error codes that go in bError (see 6.2.6) */
158 ERROR_CMD_NOT_SUPPORTED
= 0,
159 ERROR_CMD_ABORTED
= -1,
161 ERROR_XFR_PARITY_ERROR
= -3,
162 ERROR_XFR_OVERRUN
= -4,
166 /* 6.2.6 RDR_to_PC_SlotStatus definitions */
168 CLOCK_STATUS_RUNNING
= 0,
170 * 0 - Clock Running, 1 - Clock stopped in State L, 2 - H,
171 * 3 - unknown state. rest are RFU
175 typedef struct QEMU_PACKED CCID_Header
{
176 uint8_t bMessageType
;
182 typedef struct QEMU_PACKED CCID_BULK_IN
{
184 uint8_t bStatus
; /* Only used in BULK_IN */
185 uint8_t bError
; /* Only used in BULK_IN */
188 typedef struct QEMU_PACKED CCID_SlotStatus
{
190 uint8_t bClockStatus
;
193 typedef struct QEMU_PACKED CCID_T0ProtocolDataStructure
{
194 uint8_t bmFindexDindex
;
196 uint8_t bGuardTimeT0
;
197 uint8_t bWaitingIntegerT0
;
199 } CCID_T0ProtocolDataStructure
;
201 typedef struct QEMU_PACKED CCID_T1ProtocolDataStructure
{
202 uint8_t bmFindexDindex
;
204 uint8_t bGuardTimeT1
;
205 uint8_t bWaitingIntegerT1
;
209 } CCID_T1ProtocolDataStructure
;
211 typedef union CCID_ProtocolDataStructure
{
212 CCID_T0ProtocolDataStructure t0
;
213 CCID_T1ProtocolDataStructure t1
;
214 uint8_t data
[7]; /* must be = max(sizeof(t0), sizeof(t1)) */
215 } CCID_ProtocolDataStructure
;
217 typedef struct QEMU_PACKED CCID_Parameter
{
219 uint8_t bProtocolNum
;
220 CCID_ProtocolDataStructure abProtocolDataStructure
;
223 typedef struct QEMU_PACKED CCID_DataBlock
{
225 uint8_t bChainParameter
;
229 /* 6.1.4 PC_to_RDR_XfrBlock */
230 typedef struct QEMU_PACKED CCID_XferBlock
{
232 uint8_t bBWI
; /* Block Waiting Timeout */
233 uint16_t wLevelParameter
; /* XXX currently unused */
237 typedef struct QEMU_PACKED CCID_IccPowerOn
{
239 uint8_t bPowerSelect
;
243 typedef struct QEMU_PACKED CCID_IccPowerOff
{
248 typedef struct QEMU_PACKED CCID_SetParameters
{
250 uint8_t bProtocolNum
;
252 CCID_ProtocolDataStructure abProtocolDataStructure
;
253 } CCID_SetParameters
;
255 typedef struct CCID_Notify_Slot_Change
{
256 uint8_t bMessageType
; /* CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange */
257 uint8_t bmSlotICCState
;
258 } CCID_Notify_Slot_Change
;
260 /* used for DataBlock response to XferBlock */
261 typedef struct Answer
{
266 /* pending BULK_IN messages */
267 typedef struct BulkIn
{
268 uint8_t data
[BULK_IN_BUF_SIZE
];
273 typedef struct CCIDBus
{
278 * powered - defaults to true, changed by PowerOn/PowerOff messages
280 typedef struct USBCCIDState
{
286 BulkIn bulk_in_pending
[BULK_IN_PENDING_NUM
]; /* circular */
287 uint32_t bulk_in_pending_start
;
288 uint32_t bulk_in_pending_end
; /* first free */
289 uint32_t bulk_in_pending_num
;
290 BulkIn
*current_bulk_in
;
291 uint8_t bulk_out_data
[BULK_OUT_DATA_SIZE
];
292 uint32_t bulk_out_pos
;
293 uint64_t last_answer_error
;
294 Answer pending_answers
[PENDING_ANSWERS_NUM
];
295 uint32_t pending_answers_start
;
296 uint32_t pending_answers_end
;
297 uint32_t pending_answers_num
;
299 uint8_t bmCommandStatus
;
300 uint8_t bProtocolNum
;
301 CCID_ProtocolDataStructure abProtocolDataStructure
;
302 uint32_t ulProtocolDataStructureSize
;
303 uint32_t state_vmstate
;
304 uint8_t bmSlotICCState
;
306 uint8_t notify_slot_change
;
311 * CCID Spec chapter 4: CCID uses a standard device descriptor per Chapter 9,
312 * "USB Device Framework", section 9.6.1, in the Universal Serial Bus
315 * This device implemented based on the spec and with an Athena Smart Card
316 * Reader as reference:
317 * 0dc3:1004 Athena Smartcard Solutions, Inc.
320 static const uint8_t qemu_ccid_descriptor
[] = {
321 /* Smart Card Device Class Descriptor */
322 0x36, /* u8 bLength; */
323 0x21, /* u8 bDescriptorType; Functional */
324 0x10, 0x01, /* u16 bcdCCID; CCID Specification Release Number. */
326 * u8 bMaxSlotIndex; The index of the highest available
327 * slot on this device. All slots are consecutive starting
330 0x07, /* u8 bVoltageSupport; 01h - 5.0v, 02h - 3.0, 03 - 1.8 */
332 0x00, 0x00, /* u32 dwProtocols; RRRR PPPP. RRRR = 0000h.*/
333 0x01, 0x00, /* PPPP: 0001h = Protocol T=0, 0002h = Protocol T=1 */
334 /* u32 dwDefaultClock; in kHZ (0x0fa0 is 4 MHz) */
335 0xa0, 0x0f, 0x00, 0x00,
336 /* u32 dwMaximumClock; */
337 0x00, 0x00, 0x01, 0x00,
338 0x00, /* u8 bNumClockSupported; *
339 * 0 means just the default and max. */
340 /* u32 dwDataRate ;bps. 9600 == 00002580h */
341 0x80, 0x25, 0x00, 0x00,
342 /* u32 dwMaxDataRate ; 11520 bps == 0001C200h */
343 0x00, 0xC2, 0x01, 0x00,
344 0x00, /* u8 bNumDataRatesSupported; 00 means all rates between
347 * maximum IFSD supported by CCID for protocol *
348 * T=1 (Maximum seen from various cards) */
349 0xfe, 0x00, 0x00, 0x00,
350 /* u32 dwSyncProtocols; 1 - 2-wire, 2 - 3-wire, 4 - I2C */
351 0x00, 0x00, 0x00, 0x00,
352 /* u32 dwMechanical; 0 - no special characteristics. */
353 0x00, 0x00, 0x00, 0x00,
356 * 0 - No special characteristics
357 * + 2 Automatic parameter configuration based on ATR data
358 * + 4 Automatic activation of ICC on inserting
359 * + 8 Automatic ICC voltage selection
360 * + 10 Automatic ICC clock frequency change
361 * + 20 Automatic baud rate change
362 * + 40 Automatic parameters negotiation made by the CCID
363 * + 80 automatic PPS made by the CCID
364 * 100 CCID can set ICC in clock stop mode
365 * 200 NAD value other then 00 accepted (T=1 protocol)
366 * + 400 Automatic IFSD exchange as first exchange (T=1)
367 * One of the following only:
368 * + 10000 TPDU level exchanges with CCID
369 * 20000 Short APDU level exchange with CCID
370 * 40000 Short and Extended APDU level exchange with CCID
372 * 100000 USB Wake up signaling supported on card
373 * insertion and removal. Must set bit 5 in bmAttributes
374 * in Configuration descriptor if 100000 is set.
376 0xfe, 0x04, 0x01, 0x00,
378 * u32 dwMaxCCIDMessageLength; For extended APDU in
379 * [261 + 10 , 65544 + 10]. Otherwise the minimum is
380 * wMaxPacketSize of the Bulk-OUT endpoint
382 0x12, 0x00, 0x01, 0x00,
384 * u8 bClassGetResponse; Significant only for CCID that
385 * offers an APDU level for exchanges. Indicates the
386 * default class value used by the CCID when it sends a
387 * Get Response command to perform the transportation of
388 * an APDU by T=0 protocol
389 * FFh indicates that the CCID echos the class of the APDU.
392 * u8 bClassEnvelope; EAPDU only. Envelope command for
396 * u16 wLcdLayout; XXYY Number of lines (XX) and chars per
397 * line for LCD display used for PIN entry. 0000 - no LCD
400 * u8 bPINSupport; 01h PIN Verification,
401 * 02h PIN Modification
403 0x01, /* u8 bMaxCCIDBusySlots; */
407 STR_MANUFACTURER
= 1,
413 static const USBDescStrings desc_strings
= {
414 [STR_MANUFACTURER
] = "QEMU",
415 [STR_PRODUCT
] = "QEMU USB CCID",
416 [STR_SERIALNUMBER
] = "1",
417 [STR_INTERFACE
] = "CCID Interface",
420 static const USBDescIface desc_iface0
= {
421 .bInterfaceNumber
= 0,
423 .bInterfaceClass
= USB_CLASS_CSCID
,
424 .bInterfaceSubClass
= USB_SUBCLASS_UNDEFINED
,
425 .bInterfaceProtocol
= 0x00,
426 .iInterface
= STR_INTERFACE
,
428 .descs
= (USBDescOther
[]) {
430 /* smartcard descriptor */
431 .data
= qemu_ccid_descriptor
,
434 .eps
= (USBDescEndpoint
[]) {
436 .bEndpointAddress
= USB_DIR_IN
| CCID_INT_IN_EP
,
437 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
439 .wMaxPacketSize
= 64,
441 .bEndpointAddress
= USB_DIR_IN
| CCID_BULK_IN_EP
,
442 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
443 .wMaxPacketSize
= 64,
445 .bEndpointAddress
= USB_DIR_OUT
| CCID_BULK_OUT_EP
,
446 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
447 .wMaxPacketSize
= 64,
452 static const USBDescDevice desc_device
= {
454 .bMaxPacketSize0
= 64,
455 .bNumConfigurations
= 1,
456 .confs
= (USBDescConfig
[]) {
459 .bConfigurationValue
= 1,
460 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
|
469 static const USBDesc desc_ccid
= {
471 .idVendor
= CCID_VENDOR_ID
,
472 .idProduct
= CCID_PRODUCT_ID
,
473 .bcdDevice
= CCID_DEVICE_VERSION
,
474 .iManufacturer
= STR_MANUFACTURER
,
475 .iProduct
= STR_PRODUCT
,
476 .iSerialNumber
= STR_SERIALNUMBER
,
478 .full
= &desc_device
,
482 static const uint8_t *ccid_card_get_atr(CCIDCardState
*card
, uint32_t *len
)
484 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
487 return cc
->get_atr(card
, len
);
492 static void ccid_card_apdu_from_guest(CCIDCardState
*card
,
496 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
498 if (cc
->apdu_from_guest
) {
499 cc
->apdu_from_guest(card
, apdu
, len
);
503 static void ccid_card_exitfn(CCIDCardState
*card
)
505 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
513 static int ccid_card_initfn(CCIDCardState
*card
)
515 CCIDCardClass
*cc
= CCID_CARD_GET_CLASS(card
);
518 return cc
->initfn(card
);
523 static bool ccid_has_pending_answers(USBCCIDState
*s
)
525 return s
->pending_answers_num
> 0;
528 static void ccid_clear_pending_answers(USBCCIDState
*s
)
530 s
->pending_answers_num
= 0;
531 s
->pending_answers_start
= 0;
532 s
->pending_answers_end
= 0;
535 static void ccid_print_pending_answers(USBCCIDState
*s
)
540 DPRINTF(s
, D_VERBOSE
, "usb-ccid: pending answers:");
541 if (!ccid_has_pending_answers(s
)) {
542 DPRINTF(s
, D_VERBOSE
, " empty\n");
545 for (i
= s
->pending_answers_start
, count
= s
->pending_answers_num
;
546 count
> 0; count
--, i
++) {
547 answer
= &s
->pending_answers
[i
% PENDING_ANSWERS_NUM
];
549 DPRINTF(s
, D_VERBOSE
, "%d:%d\n", answer
->slot
, answer
->seq
);
551 DPRINTF(s
, D_VERBOSE
, "%d:%d,", answer
->slot
, answer
->seq
);
556 static void ccid_add_pending_answer(USBCCIDState
*s
, CCID_Header
*hdr
)
560 assert(s
->pending_answers_num
< PENDING_ANSWERS_NUM
);
561 s
->pending_answers_num
++;
563 &s
->pending_answers
[(s
->pending_answers_end
++) % PENDING_ANSWERS_NUM
];
564 answer
->slot
= hdr
->bSlot
;
565 answer
->seq
= hdr
->bSeq
;
566 ccid_print_pending_answers(s
);
569 static void ccid_remove_pending_answer(USBCCIDState
*s
,
570 uint8_t *slot
, uint8_t *seq
)
574 assert(s
->pending_answers_num
> 0);
575 s
->pending_answers_num
--;
577 &s
->pending_answers
[(s
->pending_answers_start
++) % PENDING_ANSWERS_NUM
];
578 *slot
= answer
->slot
;
580 ccid_print_pending_answers(s
);
583 static void ccid_bulk_in_clear(USBCCIDState
*s
)
585 s
->bulk_in_pending_start
= 0;
586 s
->bulk_in_pending_end
= 0;
587 s
->bulk_in_pending_num
= 0;
590 static void ccid_bulk_in_release(USBCCIDState
*s
)
592 assert(s
->current_bulk_in
!= NULL
);
593 s
->current_bulk_in
->pos
= 0;
594 s
->current_bulk_in
= NULL
;
597 static void ccid_bulk_in_get(USBCCIDState
*s
)
599 if (s
->current_bulk_in
!= NULL
|| s
->bulk_in_pending_num
== 0) {
602 assert(s
->bulk_in_pending_num
> 0);
603 s
->bulk_in_pending_num
--;
605 &s
->bulk_in_pending
[(s
->bulk_in_pending_start
++) % BULK_IN_PENDING_NUM
];
608 static void *ccid_reserve_recv_buf(USBCCIDState
*s
, uint16_t len
)
612 DPRINTF(s
, D_VERBOSE
, "%s: QUEUE: reserve %d bytes\n", __func__
, len
);
614 /* look for an existing element */
615 if (len
> BULK_IN_BUF_SIZE
) {
616 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: len larger then max (%d>%d). "
617 "discarding message.\n",
618 __func__
, len
, BULK_IN_BUF_SIZE
);
621 if (s
->bulk_in_pending_num
>= BULK_IN_PENDING_NUM
) {
622 DPRINTF(s
, D_WARN
, "usb-ccid.c: %s: No free bulk_in buffers. "
623 "discarding message.\n", __func__
);
627 &s
->bulk_in_pending
[(s
->bulk_in_pending_end
++) % BULK_IN_PENDING_NUM
];
628 s
->bulk_in_pending_num
++;
630 return bulk_in
->data
;
633 static void ccid_reset(USBCCIDState
*s
)
635 ccid_bulk_in_clear(s
);
636 ccid_clear_pending_answers(s
);
639 static void ccid_detach(USBCCIDState
*s
)
644 static void ccid_handle_reset(USBDevice
*dev
)
646 USBCCIDState
*s
= USB_CCID_DEV(dev
);
648 DPRINTF(s
, 1, "Reset\n");
653 static const char *ccid_control_to_str(USBCCIDState
*s
, int request
)
656 /* generic - should be factored out if there are other debugees */
657 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
658 return "(generic) set address";
659 case DeviceRequest
| USB_REQ_GET_DESCRIPTOR
:
660 return "(generic) get descriptor";
661 case DeviceRequest
| USB_REQ_GET_CONFIGURATION
:
662 return "(generic) get configuration";
663 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
664 return "(generic) set configuration";
665 case DeviceRequest
| USB_REQ_GET_STATUS
:
666 return "(generic) get status";
667 case DeviceOutRequest
| USB_REQ_CLEAR_FEATURE
:
668 return "(generic) clear feature";
669 case DeviceOutRequest
| USB_REQ_SET_FEATURE
:
670 return "(generic) set_feature";
671 case InterfaceRequest
| USB_REQ_GET_INTERFACE
:
672 return "(generic) get interface";
673 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
674 return "(generic) set interface";
676 case ClassInterfaceOutRequest
| CCID_CONTROL_ABORT
:
678 case ClassInterfaceRequest
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
679 return "GET_CLOCK_FREQUENCIES";
680 case ClassInterfaceRequest
| CCID_CONTROL_GET_DATA_RATES
:
681 return "GET_DATA_RATES";
686 static void ccid_handle_control(USBDevice
*dev
, USBPacket
*p
, int request
,
687 int value
, int index
, int length
, uint8_t *data
)
689 USBCCIDState
*s
= USB_CCID_DEV(dev
);
692 DPRINTF(s
, 1, "%s: got control %s (%x), value %x\n", __func__
,
693 ccid_control_to_str(s
, request
), request
, value
);
694 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
700 /* Class specific requests. */
701 case ClassInterfaceOutRequest
| CCID_CONTROL_ABORT
:
702 DPRINTF(s
, 1, "ccid_control abort UNIMPLEMENTED\n");
703 p
->status
= USB_RET_STALL
;
705 case ClassInterfaceRequest
| CCID_CONTROL_GET_CLOCK_FREQUENCIES
:
706 DPRINTF(s
, 1, "ccid_control get clock frequencies UNIMPLEMENTED\n");
707 p
->status
= USB_RET_STALL
;
709 case ClassInterfaceRequest
| CCID_CONTROL_GET_DATA_RATES
:
710 DPRINTF(s
, 1, "ccid_control get data rates UNIMPLEMENTED\n");
711 p
->status
= USB_RET_STALL
;
714 DPRINTF(s
, 1, "got unsupported/bogus control %x, value %x\n",
716 p
->status
= USB_RET_STALL
;
721 static bool ccid_card_inserted(USBCCIDState
*s
)
723 return s
->bmSlotICCState
& SLOT_0_STATE_MASK
;
726 static uint8_t ccid_card_status(USBCCIDState
*s
)
728 return ccid_card_inserted(s
)
730 ICC_STATUS_PRESENT_ACTIVE
731 : ICC_STATUS_PRESENT_INACTIVE
733 : ICC_STATUS_NOT_PRESENT
;
736 static uint8_t ccid_calc_status(USBCCIDState
*s
)
739 * page 55, 6.2.6, calculation of bStatus from bmICCStatus and
742 uint8_t ret
= ccid_card_status(s
) | (s
->bmCommandStatus
<< 6);
743 DPRINTF(s
, D_VERBOSE
, "%s: status = %d\n", __func__
, ret
);
747 static void ccid_reset_error_status(USBCCIDState
*s
)
749 s
->bError
= ERROR_CMD_NOT_SUPPORTED
;
750 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
753 static void ccid_write_slot_status(USBCCIDState
*s
, CCID_Header
*recv
)
755 CCID_SlotStatus
*h
= ccid_reserve_recv_buf(s
, sizeof(CCID_SlotStatus
));
759 h
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus
;
760 h
->b
.hdr
.dwLength
= 0;
761 h
->b
.hdr
.bSlot
= recv
->bSlot
;
762 h
->b
.hdr
.bSeq
= recv
->bSeq
;
763 h
->b
.bStatus
= ccid_calc_status(s
);
764 h
->b
.bError
= s
->bError
;
765 h
->bClockStatus
= CLOCK_STATUS_RUNNING
;
766 ccid_reset_error_status(s
);
767 usb_wakeup(s
->bulk
, 0);
770 static void ccid_write_parameters(USBCCIDState
*s
, CCID_Header
*recv
)
773 uint32_t len
= s
->ulProtocolDataStructureSize
;
775 h
= ccid_reserve_recv_buf(s
, sizeof(CCID_Parameter
) + len
);
779 h
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_Parameters
;
780 h
->b
.hdr
.dwLength
= 0;
781 h
->b
.hdr
.bSlot
= recv
->bSlot
;
782 h
->b
.hdr
.bSeq
= recv
->bSeq
;
783 h
->b
.bStatus
= ccid_calc_status(s
);
784 h
->b
.bError
= s
->bError
;
785 h
->bProtocolNum
= s
->bProtocolNum
;
786 h
->abProtocolDataStructure
= s
->abProtocolDataStructure
;
787 ccid_reset_error_status(s
);
788 usb_wakeup(s
->bulk
, 0);
791 static void ccid_write_data_block(USBCCIDState
*s
, uint8_t slot
, uint8_t seq
,
792 const uint8_t *data
, uint32_t len
)
794 CCID_DataBlock
*p
= ccid_reserve_recv_buf(s
, sizeof(*p
) + len
);
799 p
->b
.hdr
.bMessageType
= CCID_MESSAGE_TYPE_RDR_to_PC_DataBlock
;
800 p
->b
.hdr
.dwLength
= cpu_to_le32(len
);
801 p
->b
.hdr
.bSlot
= slot
;
803 p
->b
.bStatus
= ccid_calc_status(s
);
804 p
->b
.bError
= s
->bError
;
806 DPRINTF(s
, D_VERBOSE
, "error %d\n", p
->b
.bError
);
809 g_assert_nonnull(data
);
810 memcpy(p
->abData
, data
, len
);
812 ccid_reset_error_status(s
);
813 usb_wakeup(s
->bulk
, 0);
816 static void ccid_report_error_failed(USBCCIDState
*s
, uint8_t error
)
818 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
822 static void ccid_write_data_block_answer(USBCCIDState
*s
,
823 const uint8_t *data
, uint32_t len
)
828 if (!ccid_has_pending_answers(s
)) {
829 DPRINTF(s
, D_WARN
, "error: no pending answer to return to guest\n");
830 ccid_report_error_failed(s
, ERROR_ICC_MUTE
);
833 ccid_remove_pending_answer(s
, &slot
, &seq
);
834 ccid_write_data_block(s
, slot
, seq
, data
, len
);
837 static uint8_t atr_get_protocol_num(const uint8_t *atr
, uint32_t len
)
841 if (len
< 2 || !(atr
[1] & 0x80)) {
842 /* too short or TD1 not included */
843 return 0; /* T=0, default */
845 i
= 1 + !!(atr
[1] & 0x10) + !!(atr
[1] & 0x20) + !!(atr
[1] & 0x40);
846 i
+= !!(atr
[1] & 0x80);
847 return atr
[i
] & 0x0f;
850 static void ccid_write_data_block_atr(USBCCIDState
*s
, CCID_Header
*recv
)
852 const uint8_t *atr
= NULL
;
854 uint8_t atr_protocol_num
;
855 CCID_T0ProtocolDataStructure
*t0
= &s
->abProtocolDataStructure
.t0
;
856 CCID_T1ProtocolDataStructure
*t1
= &s
->abProtocolDataStructure
.t1
;
859 atr
= ccid_card_get_atr(s
->card
, &len
);
861 atr_protocol_num
= atr_get_protocol_num(atr
, len
);
862 DPRINTF(s
, D_VERBOSE
, "%s: atr contains protocol=%d\n", __func__
,
864 /* set parameters from ATR - see spec page 109 */
865 s
->bProtocolNum
= (atr_protocol_num
<= 1 ? atr_protocol_num
867 switch (atr_protocol_num
) {
869 /* TODO: unimplemented ATR T0 parameters */
870 t0
->bmFindexDindex
= 0;
872 t0
->bGuardTimeT0
= 0;
873 t0
->bWaitingIntegerT0
= 0;
877 /* TODO: unimplemented ATR T1 parameters */
878 t1
->bmFindexDindex
= 0;
880 t1
->bGuardTimeT1
= 0;
881 t1
->bWaitingIntegerT1
= 0;
887 DPRINTF(s
, D_WARN
, "%s: error: unsupported ATR protocol %d\n",
888 __func__
, atr_protocol_num
);
890 ccid_write_data_block(s
, recv
->bSlot
, recv
->bSeq
, atr
, len
);
893 static void ccid_set_parameters(USBCCIDState
*s
, CCID_Header
*recv
)
895 CCID_SetParameters
*ph
= (CCID_SetParameters
*) recv
;
896 uint32_t protocol_num
= ph
->bProtocolNum
& 3;
898 if (protocol_num
!= 0 && protocol_num
!= 1) {
899 ccid_report_error_failed(s
, ERROR_CMD_NOT_SUPPORTED
);
902 s
->bProtocolNum
= protocol_num
;
903 s
->abProtocolDataStructure
= ph
->abProtocolDataStructure
;
907 * must be 5 bytes for T=0, 7 bytes for T=1
910 static const CCID_ProtocolDataStructure defaultProtocolDataStructure
= {
912 .bmFindexDindex
= 0x77,
914 .bGuardTimeT1
= 0x00,
915 .bWaitingIntegerT1
= 0x00,
922 static void ccid_reset_parameters(USBCCIDState
*s
)
924 s
->bProtocolNum
= 0; /* T=0 */
925 s
->abProtocolDataStructure
= defaultProtocolDataStructure
;
928 /* NOTE: only a single slot is supported (SLOT_0) */
929 static void ccid_on_slot_change(USBCCIDState
*s
, bool full
)
931 /* RDR_to_PC_NotifySlotChange, 6.3.1 page 56 */
932 uint8_t current
= s
->bmSlotICCState
;
934 s
->bmSlotICCState
|= SLOT_0_STATE_MASK
;
936 s
->bmSlotICCState
&= ~SLOT_0_STATE_MASK
;
938 if (current
!= s
->bmSlotICCState
) {
939 s
->bmSlotICCState
|= SLOT_0_CHANGED_MASK
;
941 s
->notify_slot_change
= true;
942 usb_wakeup(s
->intr
, 0);
945 static void ccid_write_data_block_error(
946 USBCCIDState
*s
, uint8_t slot
, uint8_t seq
)
948 ccid_write_data_block(s
, slot
, seq
, NULL
, 0);
951 static void ccid_on_apdu_from_guest(USBCCIDState
*s
, CCID_XferBlock
*recv
)
955 if (ccid_card_status(s
) != ICC_STATUS_PRESENT_ACTIVE
) {
957 "usb-ccid: not sending apdu to client, no card connected\n");
958 ccid_write_data_block_error(s
, recv
->hdr
.bSlot
, recv
->hdr
.bSeq
);
961 len
= le32_to_cpu(recv
->hdr
.dwLength
);
962 DPRINTF(s
, 1, "%s: seq %d, len %d\n", __func__
,
963 recv
->hdr
.bSeq
, len
);
964 ccid_add_pending_answer(s
, (CCID_Header
*)recv
);
965 if (s
->card
&& len
<= BULK_OUT_DATA_SIZE
) {
966 ccid_card_apdu_from_guest(s
->card
, recv
->abData
, len
);
968 DPRINTF(s
, D_WARN
, "warning: discarded apdu\n");
972 static const char *ccid_message_type_to_str(uint8_t type
)
975 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
: return "IccPowerOn";
976 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
: return "IccPowerOff";
977 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
: return "GetSlotStatus";
978 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
: return "XfrBlock";
979 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
: return "GetParameters";
980 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
: return "ResetParameters";
981 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
: return "SetParameters";
982 case CCID_MESSAGE_TYPE_PC_to_RDR_Escape
: return "Escape";
983 case CCID_MESSAGE_TYPE_PC_to_RDR_IccClock
: return "IccClock";
984 case CCID_MESSAGE_TYPE_PC_to_RDR_T0APDU
: return "T0APDU";
985 case CCID_MESSAGE_TYPE_PC_to_RDR_Secure
: return "Secure";
986 case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical
: return "Mechanical";
987 case CCID_MESSAGE_TYPE_PC_to_RDR_Abort
: return "Abort";
988 case CCID_MESSAGE_TYPE_PC_to_RDR_SetDataRateAndClockFrequency
:
989 return "SetDataRateAndClockFrequency";
994 static void ccid_handle_bulk_out(USBCCIDState
*s
, USBPacket
*p
)
996 CCID_Header
*ccid_header
;
998 if (p
->iov
.size
+ s
->bulk_out_pos
> BULK_OUT_DATA_SIZE
) {
1001 usb_packet_copy(p
, s
->bulk_out_data
+ s
->bulk_out_pos
, p
->iov
.size
);
1002 s
->bulk_out_pos
+= p
->iov
.size
;
1003 if (s
->bulk_out_pos
< 10) {
1004 DPRINTF(s
, 1, "%s: header incomplete\n", __func__
);
1008 ccid_header
= (CCID_Header
*)s
->bulk_out_data
;
1009 if ((s
->bulk_out_pos
- 10 < ccid_header
->dwLength
) &&
1010 (p
->iov
.size
== CCID_MAX_PACKET_SIZE
)) {
1011 DPRINTF(s
, D_VERBOSE
,
1012 "usb-ccid: bulk_in: expecting more packets (%d/%d)\n",
1013 s
->bulk_out_pos
- 10, ccid_header
->dwLength
);
1016 if (s
->bulk_out_pos
- 10 != ccid_header
->dwLength
) {
1018 "usb-ccid: bulk_in: message size mismatch (got %d, expected %d)\n",
1019 s
->bulk_out_pos
- 10, ccid_header
->dwLength
);
1023 DPRINTF(s
, D_MORE_INFO
, "%s %x %s\n", __func__
,
1024 ccid_header
->bMessageType
,
1025 ccid_message_type_to_str(ccid_header
->bMessageType
));
1026 switch (ccid_header
->bMessageType
) {
1027 case CCID_MESSAGE_TYPE_PC_to_RDR_GetSlotStatus
:
1028 ccid_write_slot_status(s
, ccid_header
);
1030 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOn
:
1031 DPRINTF(s
, 1, "%s: PowerOn: %d\n", __func__
,
1032 ((CCID_IccPowerOn
*)(ccid_header
))->bPowerSelect
);
1034 if (!ccid_card_inserted(s
)) {
1035 ccid_report_error_failed(s
, ERROR_ICC_MUTE
);
1037 /* atr is written regardless of error. */
1038 ccid_write_data_block_atr(s
, ccid_header
);
1040 case CCID_MESSAGE_TYPE_PC_to_RDR_IccPowerOff
:
1041 ccid_reset_error_status(s
);
1043 ccid_write_slot_status(s
, ccid_header
);
1045 case CCID_MESSAGE_TYPE_PC_to_RDR_XfrBlock
:
1046 ccid_on_apdu_from_guest(s
, (CCID_XferBlock
*)s
->bulk_out_data
);
1048 case CCID_MESSAGE_TYPE_PC_to_RDR_SetParameters
:
1049 ccid_reset_error_status(s
);
1050 ccid_set_parameters(s
, ccid_header
);
1051 ccid_write_parameters(s
, ccid_header
);
1053 case CCID_MESSAGE_TYPE_PC_to_RDR_ResetParameters
:
1054 ccid_reset_error_status(s
);
1055 ccid_reset_parameters(s
);
1056 ccid_write_parameters(s
, ccid_header
);
1058 case CCID_MESSAGE_TYPE_PC_to_RDR_GetParameters
:
1059 ccid_reset_error_status(s
);
1060 ccid_write_parameters(s
, ccid_header
);
1062 case CCID_MESSAGE_TYPE_PC_to_RDR_Mechanical
:
1063 ccid_report_error_failed(s
, 0);
1064 ccid_write_slot_status(s
, ccid_header
);
1068 "handle_data: ERROR: unhandled message type %Xh\n",
1069 ccid_header
->bMessageType
);
1071 * The caller is expecting the device to respond, tell it we
1072 * don't support the operation.
1074 ccid_report_error_failed(s
, ERROR_CMD_NOT_SUPPORTED
);
1075 ccid_write_slot_status(s
, ccid_header
);
1078 s
->bulk_out_pos
= 0;
1082 p
->status
= USB_RET_STALL
;
1083 s
->bulk_out_pos
= 0;
1087 static void ccid_bulk_in_copy_to_guest(USBCCIDState
*s
, USBPacket
*p
)
1091 ccid_bulk_in_get(s
);
1092 if (s
->current_bulk_in
!= NULL
) {
1093 len
= MIN(s
->current_bulk_in
->len
- s
->current_bulk_in
->pos
,
1095 usb_packet_copy(p
, s
->current_bulk_in
->data
+
1096 s
->current_bulk_in
->pos
, len
);
1097 s
->current_bulk_in
->pos
+= len
;
1098 if (s
->current_bulk_in
->pos
== s
->current_bulk_in
->len
) {
1099 ccid_bulk_in_release(s
);
1102 /* return when device has no data - usb 2.0 spec Table 8-4 */
1103 p
->status
= USB_RET_NAK
;
1106 DPRINTF(s
, D_MORE_INFO
,
1107 "%s: %zd/%d req/act to guest (BULK_IN)\n",
1108 __func__
, p
->iov
.size
, len
);
1110 if (len
< p
->iov
.size
) {
1112 "%s: returning short (EREMOTEIO) %d < %zd\n",
1113 __func__
, len
, p
->iov
.size
);
1117 static void ccid_handle_data(USBDevice
*dev
, USBPacket
*p
)
1119 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1124 ccid_handle_bulk_out(s
, p
);
1128 switch (p
->ep
->nr
) {
1129 case CCID_BULK_IN_EP
:
1130 ccid_bulk_in_copy_to_guest(s
, p
);
1132 case CCID_INT_IN_EP
:
1133 if (s
->notify_slot_change
) {
1134 /* page 56, RDR_to_PC_NotifySlotChange */
1135 buf
[0] = CCID_MESSAGE_TYPE_RDR_to_PC_NotifySlotChange
;
1136 buf
[1] = s
->bmSlotICCState
;
1137 usb_packet_copy(p
, buf
, 2);
1138 s
->notify_slot_change
= false;
1139 s
->bmSlotICCState
&= ~SLOT_0_CHANGED_MASK
;
1141 "handle_data: int_in: notify_slot_change %X, "
1142 "requested len %zd\n",
1143 s
->bmSlotICCState
, p
->iov
.size
);
1145 p
->status
= USB_RET_NAK
;
1149 DPRINTF(s
, 1, "Bad endpoint\n");
1150 p
->status
= USB_RET_STALL
;
1155 DPRINTF(s
, 1, "Bad token\n");
1156 p
->status
= USB_RET_STALL
;
1161 static void ccid_unrealize(USBDevice
*dev
, Error
**errp
)
1163 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1165 ccid_bulk_in_clear(s
);
1168 static void ccid_flush_pending_answers(USBCCIDState
*s
)
1170 while (ccid_has_pending_answers(s
)) {
1171 ccid_write_data_block_answer(s
, NULL
, 0);
1175 static Answer
*ccid_peek_next_answer(USBCCIDState
*s
)
1177 return s
->pending_answers_num
== 0
1179 : &s
->pending_answers
[s
->pending_answers_start
% PENDING_ANSWERS_NUM
];
1182 static Property ccid_props
[] = {
1183 DEFINE_PROP_UINT32("slot", struct CCIDCardState
, slot
, 0),
1184 DEFINE_PROP_END_OF_LIST(),
1187 #define TYPE_CCID_BUS "ccid-bus"
1188 #define CCID_BUS(obj) OBJECT_CHECK(CCIDBus, (obj), TYPE_CCID_BUS)
1190 static const TypeInfo ccid_bus_info
= {
1191 .name
= TYPE_CCID_BUS
,
1193 .instance_size
= sizeof(CCIDBus
),
1196 void ccid_card_send_apdu_to_guest(CCIDCardState
*card
,
1197 uint8_t *apdu
, uint32_t len
)
1199 DeviceState
*qdev
= DEVICE(card
);
1200 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1201 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1204 if (!ccid_has_pending_answers(s
)) {
1205 DPRINTF(s
, 1, "CCID ERROR: got an APDU without pending answers\n");
1208 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1209 answer
= ccid_peek_next_answer(s
);
1210 if (answer
== NULL
) {
1211 DPRINTF(s
, D_WARN
, "%s: error: unexpected lack of answer\n", __func__
);
1212 ccid_report_error_failed(s
, ERROR_HW_ERROR
);
1215 DPRINTF(s
, 1, "APDU returned to guest %d (answer seq %d, slot %d)\n",
1216 len
, answer
->seq
, answer
->slot
);
1217 ccid_write_data_block_answer(s
, apdu
, len
);
1220 void ccid_card_card_removed(CCIDCardState
*card
)
1222 DeviceState
*qdev
= DEVICE(card
);
1223 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1224 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1226 ccid_on_slot_change(s
, false);
1227 ccid_flush_pending_answers(s
);
1231 int ccid_card_ccid_attach(CCIDCardState
*card
)
1233 DeviceState
*qdev
= DEVICE(card
);
1234 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1235 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1237 DPRINTF(s
, 1, "CCID Attach\n");
1241 void ccid_card_ccid_detach(CCIDCardState
*card
)
1243 DeviceState
*qdev
= DEVICE(card
);
1244 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1245 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1247 DPRINTF(s
, 1, "CCID Detach\n");
1248 if (ccid_card_inserted(s
)) {
1249 ccid_on_slot_change(s
, false);
1254 void ccid_card_card_error(CCIDCardState
*card
, uint64_t error
)
1256 DeviceState
*qdev
= DEVICE(card
);
1257 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1258 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1260 s
->bmCommandStatus
= COMMAND_STATUS_FAILED
;
1261 s
->last_answer_error
= error
;
1262 DPRINTF(s
, 1, "VSC_Error: %" PRIX64
"\n", s
->last_answer_error
);
1263 /* TODO: these errors should be more verbose and propagated to the guest.*/
1265 * We flush all pending answers on CardRemove message in ccid-card-passthru,
1266 * so check that first to not trigger abort
1268 if (ccid_has_pending_answers(s
)) {
1269 ccid_write_data_block_answer(s
, NULL
, 0);
1273 void ccid_card_card_inserted(CCIDCardState
*card
)
1275 DeviceState
*qdev
= DEVICE(card
);
1276 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1277 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1279 s
->bmCommandStatus
= COMMAND_STATUS_NO_ERROR
;
1280 ccid_flush_pending_answers(s
);
1281 ccid_on_slot_change(s
, true);
1284 static int ccid_card_exit(DeviceState
*qdev
)
1286 CCIDCardState
*card
= CCID_CARD(qdev
);
1287 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1288 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1290 if (ccid_card_inserted(s
)) {
1291 ccid_card_card_removed(card
);
1293 ccid_card_exitfn(card
);
1298 static int ccid_card_init(DeviceState
*qdev
)
1300 CCIDCardState
*card
= CCID_CARD(qdev
);
1301 USBDevice
*dev
= USB_DEVICE(qdev
->parent_bus
->parent
);
1302 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1305 if (card
->slot
!= 0) {
1306 warn_report("usb-ccid supports one slot, can't add %d",
1310 if (s
->card
!= NULL
) {
1311 warn_report("usb-ccid card already full, not adding");
1314 ret
= ccid_card_initfn(card
);
1321 static void ccid_realize(USBDevice
*dev
, Error
**errp
)
1323 USBCCIDState
*s
= USB_CCID_DEV(dev
);
1325 usb_desc_create_serial(dev
);
1327 qbus_create_inplace(&s
->bus
, sizeof(s
->bus
), TYPE_CCID_BUS
, DEVICE(dev
),
1329 qbus_set_hotplug_handler(BUS(&s
->bus
), DEVICE(dev
), &error_abort
);
1330 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, CCID_INT_IN_EP
);
1331 s
->bulk
= usb_ep_get(dev
, USB_TOKEN_IN
, CCID_BULK_IN_EP
);
1333 s
->dev
.speed
= USB_SPEED_FULL
;
1334 s
->dev
.speedmask
= USB_SPEED_MASK_FULL
;
1335 s
->notify_slot_change
= false;
1337 s
->pending_answers_num
= 0;
1338 s
->last_answer_error
= 0;
1339 s
->bulk_in_pending_start
= 0;
1340 s
->bulk_in_pending_end
= 0;
1341 s
->current_bulk_in
= NULL
;
1342 ccid_reset_error_status(s
);
1343 s
->bulk_out_pos
= 0;
1344 ccid_reset_parameters(s
);
1346 s
->debug
= parse_debug_env("QEMU_CCID_DEBUG", D_VERBOSE
, s
->debug
);
1349 static int ccid_post_load(void *opaque
, int version_id
)
1351 USBCCIDState
*s
= opaque
;
1354 * This must be done after usb_device_attach, which sets state to ATTACHED,
1355 * while it must be DEFAULT in order to accept packets (like it is after
1356 * reset, but reset will reset our addr and call our reset handler which
1357 * may change state, and we don't want to do that when migrating).
1359 s
->dev
.state
= s
->state_vmstate
;
1363 static int ccid_pre_save(void *opaque
)
1365 USBCCIDState
*s
= opaque
;
1367 s
->state_vmstate
= s
->dev
.state
;
1372 static VMStateDescription bulk_in_vmstate
= {
1373 .name
= "CCID BulkIn state",
1375 .minimum_version_id
= 1,
1376 .fields
= (VMStateField
[]) {
1377 VMSTATE_BUFFER(data
, BulkIn
),
1378 VMSTATE_UINT32(len
, BulkIn
),
1379 VMSTATE_UINT32(pos
, BulkIn
),
1380 VMSTATE_END_OF_LIST()
1384 static VMStateDescription answer_vmstate
= {
1385 .name
= "CCID Answer state",
1387 .minimum_version_id
= 1,
1388 .fields
= (VMStateField
[]) {
1389 VMSTATE_UINT8(slot
, Answer
),
1390 VMSTATE_UINT8(seq
, Answer
),
1391 VMSTATE_END_OF_LIST()
1395 static VMStateDescription usb_device_vmstate
= {
1396 .name
= "usb_device",
1398 .minimum_version_id
= 1,
1399 .fields
= (VMStateField
[]) {
1400 VMSTATE_UINT8(addr
, USBDevice
),
1401 VMSTATE_BUFFER(setup_buf
, USBDevice
),
1402 VMSTATE_BUFFER(data_buf
, USBDevice
),
1403 VMSTATE_END_OF_LIST()
1407 static VMStateDescription ccid_vmstate
= {
1410 .minimum_version_id
= 1,
1411 .post_load
= ccid_post_load
,
1412 .pre_save
= ccid_pre_save
,
1413 .fields
= (VMStateField
[]) {
1414 VMSTATE_STRUCT(dev
, USBCCIDState
, 1, usb_device_vmstate
, USBDevice
),
1415 VMSTATE_UINT8(debug
, USBCCIDState
),
1416 VMSTATE_BUFFER(bulk_out_data
, USBCCIDState
),
1417 VMSTATE_UINT32(bulk_out_pos
, USBCCIDState
),
1418 VMSTATE_UINT8(bmSlotICCState
, USBCCIDState
),
1419 VMSTATE_UINT8(powered
, USBCCIDState
),
1420 VMSTATE_UINT8(notify_slot_change
, USBCCIDState
),
1421 VMSTATE_UINT64(last_answer_error
, USBCCIDState
),
1422 VMSTATE_UINT8(bError
, USBCCIDState
),
1423 VMSTATE_UINT8(bmCommandStatus
, USBCCIDState
),
1424 VMSTATE_UINT8(bProtocolNum
, USBCCIDState
),
1425 VMSTATE_BUFFER(abProtocolDataStructure
.data
, USBCCIDState
),
1426 VMSTATE_UINT32(ulProtocolDataStructureSize
, USBCCIDState
),
1427 VMSTATE_STRUCT_ARRAY(bulk_in_pending
, USBCCIDState
,
1428 BULK_IN_PENDING_NUM
, 1, bulk_in_vmstate
, BulkIn
),
1429 VMSTATE_UINT32(bulk_in_pending_start
, USBCCIDState
),
1430 VMSTATE_UINT32(bulk_in_pending_end
, USBCCIDState
),
1431 VMSTATE_STRUCT_ARRAY(pending_answers
, USBCCIDState
,
1432 PENDING_ANSWERS_NUM
, 1, answer_vmstate
, Answer
),
1433 VMSTATE_UINT32(pending_answers_num
, USBCCIDState
),
1434 VMSTATE_UNUSED(1), /* was migration_state */
1435 VMSTATE_UINT32(state_vmstate
, USBCCIDState
),
1436 VMSTATE_END_OF_LIST()
1440 static Property ccid_properties
[] = {
1441 DEFINE_PROP_UINT8("debug", USBCCIDState
, debug
, 0),
1442 DEFINE_PROP_END_OF_LIST(),
1445 static void ccid_class_initfn(ObjectClass
*klass
, void *data
)
1447 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1448 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1449 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
1451 uc
->realize
= ccid_realize
;
1452 uc
->product_desc
= "QEMU USB CCID";
1453 uc
->usb_desc
= &desc_ccid
;
1454 uc
->handle_reset
= ccid_handle_reset
;
1455 uc
->handle_control
= ccid_handle_control
;
1456 uc
->handle_data
= ccid_handle_data
;
1457 uc
->unrealize
= ccid_unrealize
;
1458 dc
->desc
= "CCID Rev 1.1 smartcard reader";
1459 dc
->vmsd
= &ccid_vmstate
;
1460 dc
->props
= ccid_properties
;
1461 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1462 hc
->unplug
= qdev_simple_device_unplug_cb
;
1465 static const TypeInfo ccid_info
= {
1466 .name
= CCID_DEV_NAME
,
1467 .parent
= TYPE_USB_DEVICE
,
1468 .instance_size
= sizeof(USBCCIDState
),
1469 .class_init
= ccid_class_initfn
,
1470 .interfaces
= (InterfaceInfo
[]) {
1471 { TYPE_HOTPLUG_HANDLER
},
1476 static void ccid_card_class_init(ObjectClass
*klass
, void *data
)
1478 DeviceClass
*k
= DEVICE_CLASS(klass
);
1479 k
->bus_type
= TYPE_CCID_BUS
;
1480 k
->init
= ccid_card_init
;
1481 k
->exit
= ccid_card_exit
;
1482 k
->props
= ccid_props
;
1485 static const TypeInfo ccid_card_type_info
= {
1486 .name
= TYPE_CCID_CARD
,
1487 .parent
= TYPE_DEVICE
,
1488 .instance_size
= sizeof(CCIDCardState
),
1490 .class_size
= sizeof(CCIDCardClass
),
1491 .class_init
= ccid_card_class_init
,
1494 static void ccid_register_types(void)
1496 type_register_static(&ccid_bus_info
);
1497 type_register_static(&ccid_card_type_info
);
1498 type_register_static(&ccid_info
);
1499 usb_legacy_register(CCID_DEV_NAME
, "ccid", NULL
);
1502 type_init(ccid_register_types
)